package com.ruoyi.quartz.task;
|
|
import com.alibaba.fastjson2.JSONObject;
|
import com.fasterxml.jackson.databind.JsonNode;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.google.gson.Gson;
|
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.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.*;
|
import com.smartor.service.*;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.collections4.CollectionUtils;
|
import org.apache.commons.lang3.ObjectUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Component;
|
|
import java.io.IOException;
|
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.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.time.ZoneId;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static cn.hutool.core.convert.Convert.toHex;
|
|
/**
|
* 定时任务调度测试
|
*
|
* @author ruoyi
|
*/
|
@Slf4j
|
@Component("ryTask")
|
public class RyTask {
|
@Autowired
|
private IServiceThirdDataService iServiceThirdDataService;
|
|
@Autowired
|
private IServiceOutPathService iServiceOutPathService;
|
|
@Autowired
|
private IServiceSubtaskAnswerService serviceSubtaskAnswerService;
|
|
@Autowired
|
private IPatMedInhospService iPatMedInhospService;
|
|
@Autowired
|
private IPatMedOuthospService iPatMedOuthospService;
|
|
@Autowired
|
private IPatMedOperationService iPatMedOperationService;
|
|
@Autowired
|
private IServiceSubtaskService iServiceSubtaskService;
|
|
@Autowired
|
private IServicePatientTempService iServicePatientTempService;
|
|
@Autowired
|
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;
|
|
@Value("${req_path}")
|
private String req_path;
|
|
@Value("${visitHosp}")
|
private Integer visitHosp;
|
|
@Autowired
|
private ServiceTaskMapper serviceTaskMapper;
|
|
@Autowired
|
private ServiceSubtaskMapper serviceSubtaskMapper;
|
|
@Autowired
|
private RedisCache redisCache;
|
|
@Autowired
|
private IServiceSubtaskRecordService serviceSubtaskRecordService;
|
|
@Autowired
|
IBaseSmsaccountService baseSmsaccountService;
|
|
@Autowired
|
IPatArchiveService patArchiveService;
|
|
|
@Autowired
|
IPatMedOuthospService patMedOuthospService;
|
|
@Autowired
|
ISvyTaskTemplateService svyTaskTemplateService;
|
|
@Autowired
|
IIvrTaskTemplateService iIvrTaskTemplateService;
|
|
@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));
|
}
|
|
public void ryParams(String params) {
|
System.out.println("执行有参方法：" + params);
|
}
|
|
public void ryNoParams() {
|
System.out.println("执行无参方法");
|
}
|
|
public void importData() {
|
String filePath = "C:\\Users\\86176\\Desktop\\新建文本文档 4.txt"; // 替换为你的文件路径
|
|
try {
|
// 读取文件内容
|
String jsonContent = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);
|
|
// 创建ObjectMapper对象
|
ObjectMapper objectMapper = new ObjectMapper();
|
// 解析JSON为JsonNode
|
JsonNode rootNode = objectMapper.readTree(jsonContent);
|
// 获取resultList
|
JsonNode resultListNode = rootNode.path("results").path("resultList");
|
// 遍历resultList中的每个对象
|
for (JsonNode item : resultListNode) {
|
|
SysUserImport person = objectMapper.treeToValue(item, SysUserImport.class);
|
person.setStaffPhoto("");
|
sysUserImportMapper.insertSysUserImport(person);
|
|
}
|
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
|
}
|
|
public void analysisData() {
|
System.out.println("---------------------------");
|
//数据解析
|
ServiceThirdData serviceThirdData = new ServiceThirdData();
|
serviceThirdData.setDataType("ADT^A03");
|
serviceThirdData.setIsDeal(0);
|
serviceThirdData.setCreateTime(new Date());
|
iServiceThirdDataService.queryList(serviceThirdData);
|
|
}
|
|
/**
|
* 定时处理外链的数据
|
*/
|
public void runServiceSubTaskAnswer() {
|
serviceSubtaskAnswerService.saveQuestionAnswer(null, 0L);
|
}
|
|
|
/**
|
* 处理HIS数据采集
|
* 定时任务：采集患者信息、出院、门诊数据
|
*/
|
public void dealHisData() {
|
log.info("【dealHisData】开始执行HIS数据采集任务");
|
// 获取昨天0点到今天0点的时间范围
|
LocalDateTime todayZero = LocalDateTime.now().with(LocalTime.MIN);
|
LocalDateTime yesterdayZero = todayZero.minusDays(1);
|
log.info("【dealHisData】采集时间范围：{} ~ {}", yesterdayZero, todayZero);
|
|
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);
|
// 当前日期
|
LocalDate currentDate = LocalDate.now();
|
// 定义日期格式
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd ");
|
|
// 从开始日期到当前日期逐天打印
|
for (LocalDate date = endDate; !date.isAfter(currentDate); date = date.plusDays(1)) {
|
System.out.println(date.format(formatter));
|
ixhGatherPatArchiveService.getInHospDataGather("0", date.minusDays(1).atStartOfDay(), date.atStartOfDay());
|
ixhGatherPatArchiveService.getInHospDataGather("1", date.minusDays(1).atStartOfDay(), date.atStartOfDay());
|
}
|
|
}
|
|
/**
|
* 处理患者信息，进入子任务表
|
*/
|
public void dealOutHospInfo() {
|
if (port.equals("8095")) {
|
//出院表
|
iPatMedInhospService.dealOutHospInfo();
|
//门诊表
|
if (visitHosp != 1) {
|
iPatMedOuthospService.dealOutpatientInfo();
|
}
|
}
|
}
|
|
|
/**
|
* 处理手术信息，进入子任务表
|
*/
|
public void dealOperationInfo() {
|
if (port.equals("8095")) iPatMedOperationService.dealOperationInfo();
|
|
}
|
|
/**
|
* 处理患者信息，进入子任务表(微信小程序)
|
*/
|
public void dealOutHospInfoXHC() {
|
if (port.equals("8095")) {
|
PatMedInhosp patMedInhosp = new PatMedInhosp();
|
//获取未处理的数据
|
List<ServicePatientTemp> servicePatientTemps = iServicePatientTempService.selectServicePatientTempList(new ServicePatientTemp());
|
}
|
}
|
|
|
/**
|
* 长期任务执行
|
*/
|
public void longTaskSend() {
|
//获取任务信息
|
ServiceTask st = new ServiceTask();
|
st.setDelFlag("0");
|
st.setLongTask(1);
|
List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);
|
log.info("【longTaskSend】获取到{}个长期任务", serviceTasks.size());
|
for (ServiceTask serviceTask : serviceTasks) {
|
CommonTaskcallMQ commonTaskcallMQ = new CommonTaskcallMQ();
|
commonTaskcallMQ.setTaskid(serviceTask.getTaskid());
|
commonTaskcallMQ.setPreachform(serviceTask.getPreachform());
|
commonTaskcallMQ.setSendType("2");
|
|
//通过任务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);
|
|
}
|
|
}
|
|
}
|
|
|
/**
|
* 判断日期是否是今天
|
*
|
* @param date
|
* @return
|
*/
|
public boolean isDateToday(Date date) {
|
if (date == null) {
|
return false;
|
}
|
// 将 Date 转为 LocalDate
|
LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
|
// 获取今天的 LocalDate
|
LocalDate today = LocalDate.now();
|
// 如果日期早于或等于今天，返回 true
|
return !localDate.isAfter(today);
|
}
|
|
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;
|
}
|
|
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;
|
}
|
|
if (org.apache.commons.lang3.StringUtils.isEmpty(serviceSubtask.getPhone())) {
|
setSuccessPreachForm(serviceSubtask, sendPreachform, "手机号为空", "4");
|
return;
|
}
|
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 (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 {
|
HeLibrary heLibrary = heLibraryMapper.selectHeLibraryById(serviceSubtask.getLibtemplateid());
|
if ("2".equals(heLibrary.getHetype())) {
|
sendMagParam.setPhone(serviceSubtask.getPhone());
|
sendMagParam.setContent(heLibrary.getPreachcontent());
|
}
|
}
|
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
|
|
|
}
|
//任务发送记录
|
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 + "¶m2=" + patid + "¶m3=" + URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()) + "¶m5=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 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);
|
}
|
|
// 情况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 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<>();
|
|
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);
|
xinHuaWXReq.setPatientid(setPatientid);
|
xinHuaWXReq.setPatientname(setPatientname);
|
xinHuaWXReq.setMobile(phone);
|
xinHuaWXReq.setMedcardno(null);
|
xinHuaWXReq.setTitlename(taskName);
|
xinHuaWXReq.setContent(taskDesc);
|
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 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());
|
}
|
|
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;
|
}
|
}
|
