package com.smartor.service.impl;
|
|
import com.ruoyi.othervisit.api.OtherVisitFacade;
|
import com.ruoyi.inhospvisit.api.InhospVisitFacade;
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.fasterxml.jackson.core.type.TypeReference;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.ruoyi.common.core.service.dto.PatMedReq;
|
import com.ruoyi.common.core.service.dto.PatMedRes;
|
import com.ruoyi.common.utils.DateUtils;
|
import com.ruoyi.common.utils.DtoConversionUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.smartor.domain.*;
|
import com.ruoyi.inhospvisit.domain.PatMedInhospDTO;
|
import com.smartor.mapper.*;
|
import com.smartor.service.IPatMedInhospService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.collections4.CollectionUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.ObjectUtils;
|
|
import java.time.Instant;
|
import java.time.temporal.ChronoUnit;
|
import java.util.*;
|
import com.ruoyi.othervisit.domain.PatMedOperationItem;
|
import com.ruoyi.inhospvisit.domain.PatMedInhospVO;
|
import com.ruoyi.inhospvisit.domain.PatMedInhosp;
|
import com.ruoyi.common.core.domain.entity.PatArchive;
|
import com.ruoyi.task.domain.entity.ServiceSubtaskEntity;
|
import com.ruoyi.task.domain.ServiceSubtask;
|
import com.ruoyi.task.domain.ServiceTask;
|
import com.ruoyi.task.domain.ServiceTaskdept;
|
import com.ruoyi.task.domain.ServiceTaskdiag;
|
import com.ruoyi.task.domain.ServiceTaskoper;
|
import com.ruoyi.task.domain.ServiceTaskRule;
|
import com.ruoyi.task.domain.ServiceTaskSchedule;
|
import com.ruoyi.task.domain.ServiceTaskScheduleDetail;
|
import com.ruoyi.task.mapper.ServiceSubtaskMapper;
|
import com.ruoyi.task.mapper.ServiceTaskdeptMapper;
|
import com.ruoyi.task.mapper.ServiceTaskdiagMapper;
|
import com.ruoyi.task.mapper.ServiceTaskMapper;
|
import com.ruoyi.task.mapper.ServiceTaskoperMapper;
|
import com.ruoyi.task.mapper.ServiceTaskRuleMapper;
|
import com.ruoyi.task.mapper.ServiceTaskScheduleDetailMapper;
|
import com.ruoyi.task.mapper.ServiceTaskScheduleMapper;
|
import com.ruoyi.task.domain.ServiceSubtaskPreachform;
|
import com.ruoyi.task.common.ScheduleSubtaskBuilder;
|
import com.ruoyi.task.mapper.ServiceSubtaskPreachformMapper;
|
import com.ruoyi.patarchive.domain.PatArchiveImport;
|
import com.ruoyi.patarchive.mapper.PatArchiveImportMapper;
|
import com.ruoyi.patarchive.mapper.PatArchiveMapper;
|
/**
|
* 患者住院记录Service业务层处理
|
*
|
* @author smartor
|
* @date 2023-03-04
|
*/
|
@Slf4j
|
@Service
|
public class PatMedInhospServiceImpl implements IPatMedInhospService {
|
|
@Autowired
|
private InhospVisitFacade inhospVisitFacade;
|
|
/**
|
* 手术数据一律经 ruoyi-othervisit 的门面取用（跨模块数据访问原则）。
|
*/
|
@Autowired
|
private OtherVisitFacade otherVisitFacade;
|
@Autowired
|
private ServiceTaskdeptMapper serviceTaskdeptMapper;
|
@Autowired
|
private ServiceTaskdiagMapper serviceTaskdiagMapper;
|
@Autowired
|
private ServiceTaskoperMapper serviceTaskoperMapper;
|
@Autowired
|
private PatArchiveMapper patArchiveMapper;
|
@Autowired
|
private PatArchiveImportMapper patArchiveImportMapper;
|
@Autowired
|
private ServiceTaskMapper serviceTaskMapper;
|
@Autowired
|
private ServiceSubtaskMapper serviceSubtaskMapper;
|
@Autowired
|
private ServiceSubtaskPreachformMapper serviceSubtaskPreachformMapper;
|
@Autowired
|
private ServiceTaskRuleMapper serviceTaskRuleMapper;
|
|
@Value("${spring.profiles.active}")
|
private String active;
|
@Autowired
|
private ServiceTaskScheduleMapper serviceTaskScheduleMapper;
|
|
@Autowired
|
private ScheduleSubtaskBuilder scheduleSubtaskBuilder;
|
@Autowired
|
private ServiceTaskScheduleDetailMapper serviceTaskScheduleDetailMapper;
|
|
@Override
|
public List<PatMedInhosp> selectPatMedInhosp(PatMedInhosp patMedInhosp) {
|
return inhospVisitFacade.selectPatMedInhosp(patMedInhosp);
|
}
|
|
/**
|
* 查询患者住院记录列表
|
*
|
* @param patMedInhosp 患者住院记录
|
* @return 患者住院记录
|
*/
|
@Override
|
public List<PatMedInhosp> selectPatMedInhospList(PatMedInhosp patMedInhosp) {
|
//入院床位排序只在「在院」查询（cry=0）下生效，其它查询一律忽略，保证原有排序不变
|
patMedInhosp.setBedSort(normalizeBedSort(patMedInhosp.getCry(), patMedInhosp.getBedSort()));
|
if (patMedInhosp.getCry() != null && patMedInhosp.getCry() == 0) {
|
patMedInhosp.setDeptcodeList(patMedInhosp.getLeaveldeptcodes());
|
patMedInhosp.setHospitaldistrictcodeList(patMedInhosp.getLeavehospitaldistrictcodes());
|
patMedInhosp.setLeaveldeptcodes(null);
|
patMedInhosp.setLeavehospitaldistrictcodes(null);
|
patMedInhosp.setInhospstate("0");
|
} else if (patMedInhosp.getCry() != null && patMedInhosp.getCry() == 1) {
|
patMedInhosp.setInhospstate("1");
|
} else if (patMedInhosp.getCry() != null && patMedInhosp.getCry() == 2) {
|
patMedInhosp.setInhospstate("2");
|
} else if (patMedInhosp.getCry() != null && patMedInhosp.getCry() == 3) {
|
patMedInhosp.setInhospstate("3");
|
}
|
|
List<PatMedInhosp> patMedInhospList = inhospVisitFacade.selectPatMedInhospList(patMedInhosp);
|
fillTagname(patMedInhospList);
|
return patMedInhospList;
|
}
|
|
/**
|
* 批量填充患者标签
|
* <p>
|
* 原实现是每行调一次 getTagnameBypatid，SQL 往返次数随 pageSize 线性增长；
|
* 这里按 patid 去重后分批一次查回，结果与逐行查询完全一致（患者无标签时仍为 null）。
|
*
|
* @param patMedInhospList 待填充的住院记录，允许为空
|
*/
|
private void fillTagname(List<PatMedInhosp> patMedInhospList) {
|
if (CollectionUtils.isEmpty(patMedInhospList)) {
|
return;
|
}
|
// LinkedHashSet 去重同时保持顺序，避免 IN 列表出现重复 patid
|
Set<Long> patids = new LinkedHashSet<>();
|
for (PatMedInhosp patMedInhosp : patMedInhospList) {
|
if (patMedInhosp.getPatid() != null) {
|
patids.add(patMedInhosp.getPatid());
|
}
|
}
|
if (patids.isEmpty()) {
|
return;
|
}
|
|
Map<Long, String> tagnameMap = new HashMap<>();
|
List<Long> patidList = new ArrayList<>(patids);
|
// 分片，防止 IN 参数过多
|
int batchSize = 1000;
|
for (int i = 0; i < patidList.size(); i += batchSize) {
|
List<Long> batch = patidList.subList(i, Math.min(i + batchSize, patidList.size()));
|
List<Map<String, Object>> rows = inhospVisitFacade.getTagnameByPatids(batch);
|
if (CollectionUtils.isEmpty(rows)) {
|
continue;
|
}
|
for (Map<String, Object> row : rows) {
|
Object patid = row.get("patid");
|
Object tagname = row.get("tagname");
|
if (patid != null) {
|
tagnameMap.put(((Number) patid).longValue(), tagname == null ? null : tagname.toString());
|
}
|
}
|
}
|
|
for (PatMedInhosp patMedInhosp : patMedInhospList) {
|
if (patMedInhosp.getPatid() != null) {
|
patMedInhosp.setTagname(tagnameMap.get(patMedInhosp.getPatid()));
|
}
|
}
|
}
|
|
/**
|
* 归一化入院床位排序参数
|
* <p>
|
* asc / 1 -> asc（床位正序），desc / 2 -> desc（床位倒序），其余（含不传）-> null（不排序）。
|
* 只对「在院」患者查询（cry=0）生效，出院/转科等查询忽略该参数。
|
*
|
* @param cry 出入院标识：0入院 1出院 2转科 3预入院
|
* @param bedSort 前端传入的床位排序值
|
* @return 归一化后的排序值（asc / desc / null）
|
*/
|
private String normalizeBedSort(Integer cry, String bedSort) {
|
if (cry == null || cry != 0 || StringUtils.isEmpty(bedSort)) return null;
|
String value = bedSort.trim().toLowerCase();
|
if ("asc".equals(value) || "1".equals(value)) return "asc";
|
if ("desc".equals(value) || "2".equals(value)) return "desc";
|
return null;
|
}
|
|
@Override
|
public List<PatMedInhospDTO> selectPatMedInhospByApplication(PatMedInhosp patMedInhosp) {
|
List<PatMedInhosp> patMedInhosps = selectPatMedInhospList(patMedInhosp);
|
if (!org.springframework.util.CollectionUtils.isEmpty(patMedInhosps)) {
|
return null;
|
}
|
List<PatMedInhospDTO> patMedInhospDTOList = DtoConversionUtils.sourceToTarget(patMedInhosps, PatMedInhospDTO.class);
|
for (PatMedInhospDTO pmd : patMedInhospDTOList) {
|
ServiceSubtaskEntity serviceSubtask = new ServiceSubtaskEntity();
|
serviceSubtask.setServiceType("4");
|
serviceSubtask.setInhospid(pmd.getInhospid());
|
List<ServiceSubtask> serviceSubtasks = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtask);
|
if (CollectionUtils.isNotEmpty(serviceSubtasks)) pmd.setFinishFlag("1");
|
}
|
|
return patMedInhospDTOList;
|
}
|
|
/**
|
* 查询当前登陆人自己（病区、部门）的患者住院记录列表
|
*
|
* @param patMedInhospVO
|
* @return
|
*/
|
public List<PatMedInhosp> selectPatMedInhospListByCondition(PatMedInhospVO patMedInhospVO) {
|
return inhospVisitFacade.selectPatMedInhospListByCondition(patMedInhospVO);
|
}
|
|
|
@Override
|
public PatMedInhosp getDeptCodeByPatId(PatMedInhosp patMedInhosp) {
|
List<PatMedInhosp> patMedInhosps = selectPatMedInhospList(patMedInhosp);
|
if (!org.springframework.util.CollectionUtils.isEmpty(patMedInhosps)) {
|
|
if (patMedInhosp.getInhospstate().equals("0")) {
|
//先去掉时间为空的
|
patMedInhosps.removeIf(PatMedInhosp -> PatMedInhosp.getStarttime() == null);
|
Collections.sort(patMedInhosps, Comparator.comparing(PatMedInhosp::getStarttime).reversed());
|
} else if (patMedInhosp.getInhospstate().equals("1")) {
|
//先去掉时间为空的
|
patMedInhosps.removeIf(PatMedInhosp -> PatMedInhosp.getEndtime() == null);
|
Collections.sort(patMedInhosps, Comparator.comparing(PatMedInhosp::getEndtime).reversed());
|
}
|
}
|
if (patMedInhosps != null && patMedInhosps.size() > 0) return patMedInhosps.get(0);
|
else return null;
|
}
|
|
/**
|
* 新增患者住院记录
|
*
|
* @param patMedInhosp 患者住院记录
|
* @return 结果
|
*/
|
@Override
|
public int insertPatMedInhosp(PatMedInhosp patMedInhosp) {
|
patMedInhosp.setCreateTime(DateUtils.getNowDate());
|
patMedInhosp.setUpdateTime(DateUtils.getNowDate());
|
return inhospVisitFacade.insertPatMedInhosp(patMedInhosp);
|
}
|
|
/**
|
* 修改患者住院记录
|
*
|
* @param patMedInhosp 患者住院记录
|
* @return 结果
|
*/
|
@Override
|
public int updatePatMedInhosp(PatMedInhosp patMedInhosp) {
|
patMedInhosp.setUpdateTime(DateUtils.getNowDate());
|
return inhospVisitFacade.updatePatMedInhosp(patMedInhosp);
|
}
|
|
/**
|
* 获取出院，住院，门诊服务人次
|
*
|
* @param patMedReq
|
* @return
|
*/
|
@Override
|
public List<PatMedRes> getDeptRanking(PatMedReq patMedReq) {
|
|
return serviceSubtaskMapper.getDeptRanking(patMedReq);
|
}
|
|
@Override
|
public List<PatMedInhosp> getDocAndPat(PatMedInhosp patMedInhosp) {
|
List<PatMedInhosp> patMedInhospList = inhospVisitFacade.selectPatMedInhospList(patMedInhosp);
|
for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
|
String tagname = inhospVisitFacade.getTagnameBypatid(patMedInhosp1.getPatid());
|
patMedInhosp1.setTagname(tagname);
|
}
|
if (StringUtils.isNotEmpty(patMedInhosp.getPatname()) || StringUtils.isNotEmpty(patMedInhosp.getNurseName()) || StringUtils.isNotEmpty(patMedInhosp.getDrname())) {
|
//获取外部导入信息,并将外部患者放到patMedInhospList中
|
PatArchiveImport patArchiveImport = new PatArchiveImport();
|
if (StringUtils.isNotEmpty(patMedInhosp.getPatname())) {
|
patArchiveImport.setName(patMedInhosp.getPatname());
|
}
|
if (StringUtils.isNotEmpty(patMedInhosp.getNurseName()))
|
patArchiveImport.setCreateBy(patMedInhosp.getNurseName());
|
if (StringUtils.isNotEmpty(patMedInhosp.getDrname()))
|
patArchiveImport.setCreateBy(patMedInhosp.getDrname());
|
List<PatArchiveImport> patArchiveImports = patArchiveImportMapper.selectPatArchiveImportList(patArchiveImport);
|
if (CollectionUtils.isNotEmpty(patArchiveImports)) {
|
for (PatArchiveImport patArchiveImport1 : patArchiveImports) {
|
PatMedInhosp patMedInhosp1 = new PatMedInhosp();
|
patMedInhosp1.setPatname(patArchiveImport1.getName());
|
patMedInhosp1.setSex(patArchiveImport1.getSex());
|
patMedInhosp1.setNurseName(patArchiveImport1.getCreateBy());
|
patMedInhosp1.setOutImport(1);
|
patMedInhosp1.setTelcode(patArchiveImport1.getTelcode());
|
patMedInhospList.add(patMedInhosp1);
|
}
|
}
|
}
|
|
return patMedInhospList;
|
}
|
|
private Date addDays(Date date, Integer days) {
|
if (days == null) {
|
days = 1;
|
}
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(date);
|
calendar.add(Calendar.DAY_OF_MONTH, days);
|
return calendar.getTime();
|
}
|
|
/**
|
* @param taskid 任务id
|
* @param check 是否需要校验
|
* @param patMedInhosp1 病人出入院信息
|
* @param patArchive 病人信息
|
* @param type 随访类型(0-宣教，1-科室，2-病区，3-疾病 4-入院科室 5-入院病区)
|
* @param config 配置信息 visit.early.day
|
*/
|
//将患者放到subtask中
|
private void writeInSubTask(Long taskid, Boolean check, PatMedInhosp patMedInhosp1, PatArchive patArchive, Integer type, String config) {
|
String longTaskReason = patMedInhosp1.getLongTaskReason();
|
String orgId = patMedInhosp1.getOrgid();
|
if (StringUtils.isEmpty(longTaskReason)) longTaskReason = "";
|
ServiceTask st = new ServiceTask();
|
st.setTaskid(taskid);
|
st.setSendState(2L);
|
List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);
|
ServiceTask serviceTask = null;
|
if (CollectionUtils.isEmpty(serviceTasks)) {
|
if (type == 0) {
|
log.info("该患者药品宣教长期任务不存在,任务ID为：{}", taskid);
|
patMedInhosp1.setMedcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者药品宣教长期任务不存在,任务ID为:" + taskid);
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
return;
|
}
|
if (type == 1) {
|
log.info("该患者出院随访长期任务不存在,任务ID为：{}", taskid);
|
patMedInhosp1.setDeptcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者离院科室长期任务不存在,任务ID为:" + taskid);
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
return;
|
} else if (type == 2) {
|
patMedInhosp1.setWardcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者离院病区长期任务不存在,任务ID为:" + taskid);
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
return;
|
} else if (type == 3) {
|
patMedInhosp1.setDiagcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者疾病长期任务不存在,任务ID为:" + taskid);
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
return;
|
} else if (type == 4) {
|
patMedInhosp1.setInDeptcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者入院科室长期任务不存在,任务ID为:" + taskid);
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
return;
|
} else if (type == 5) {
|
patMedInhosp1.setInWardcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者入院病区长期任务不存在,任务ID为:" + taskid);
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
return;
|
}
|
} else {
|
serviceTask = serviceTasks.get(0);
|
}
|
if (patMedInhosp1.getInhospstate().equals("1") && Objects.isNull(patMedInhosp1.getEndtime())) {
|
return;
|
}
|
//封装serviceSubtask
|
ServiceSubtask serviceSubtask = boxedServiceSubtask(serviceTask, patMedInhosp1, patArchive, config, type);
|
if (ObjectUtils.isEmpty(serviceSubtask)) {
|
return;
|
}
|
if (type != 2) {
|
//科室和疾病 都用 科室填充
|
if (patMedInhosp1.getInhospstate().equals("1")) {
|
serviceSubtask.setVisitDeptCode(patMedInhosp1.getLeaveldeptcode());
|
serviceSubtask.setVisitDeptName(patMedInhosp1.getLeaveldeptname());
|
} else if (patMedInhosp1.getInhospstate().equals("0")) {
|
serviceSubtask.setVisitDeptCode(patMedInhosp1.getDeptcode());
|
serviceSubtask.setVisitDeptName(patMedInhosp1.getDeptname());
|
if (type == 5) {
|
serviceSubtask.setVisitDeptCode(patMedInhosp1.getHospitaldistrictcode());
|
serviceSubtask.setVisitDeptName(patMedInhosp1.getHospitaldistrictname());
|
}
|
}
|
} else if (type == 2) {
|
serviceSubtask.setVisitDeptCode(patMedInhosp1.getLeavehospitaldistrictcode());
|
serviceSubtask.setVisitDeptName(patMedInhosp1.getLeavehospitaldistrictname());
|
}
|
//记录insertServiceSubtask语句返回状态
|
Integer i = 0;
|
try {
|
//先判断一下，是否需要校验
|
if (check && (Objects.isNull(serviceSubtask.getTaskSituation()) || serviceSubtask.getTaskSituation() != 6)) {
|
//在新增之前，先通过患者ID，sendstate=2查询一下，在所有长期任务中，是不是还有该患者待执行的任务，有的话,比较之前的endtime是否小于当前的endtaime,如果之前的小于现在的，则直接将之前的停掉（原因再入院）
|
ServiceSubtaskEntity subtask = new ServiceSubtaskEntity();
|
subtask.setPatid(patArchive.getId());
|
subtask.setSendstate(2L);
|
subtask.setTaskid(taskid);
|
List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
|
// log.info("该患者待执行的任务:{}", CollectionUtils.isNotEmpty(selectServiceSubtaskList) ? selectServiceSubtaskList.size() : null);
|
if (CollectionUtils.isNotEmpty(selectServiceSubtaskList) && selectServiceSubtaskList.size() > 0) {
|
for (ServiceSubtask serviceSubtask1 : selectServiceSubtaskList) {
|
if (Objects.isNull(serviceSubtask1.getLongSendTime())) {
|
//不是长期任务，不处理
|
continue;
|
}
|
//type = 1或2 表示 ”科室、病区“
|
if (type == 1 || type == 2) {
|
Date endTime = serviceSubtask.getEndtime();
|
Date endTime1 = serviceSubtask1.getEndtime();
|
//出院时间判空，如果为空跳过
|
if (ObjectUtils.isEmpty(endTime)) {
|
serviceSubtask.setResult("error");
|
serviceSubtask.setRemark("出院时间为空，serviceSubtask的Id为" + serviceSubtask.getId());
|
serviceSubtask.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtask.setUpdateTime(new Date());
|
Boolean aBoolean = serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
|
if (aBoolean) i = 1;
|
continue;
|
}
|
if (ObjectUtils.isEmpty(endTime1)) {
|
serviceSubtask1.setResult("error");
|
serviceSubtask1.setRemark("出院时间为空，serviceSubtask的Id为" + serviceSubtask1.getId());
|
serviceSubtask1.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtask1.setUpdateTime(new Date());
|
Boolean aBoolean = serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
|
if (aBoolean) i = 1;
|
continue;
|
}
|
//再入院逻辑
|
//景宁 出院首次（7天）随访一定要做
|
boolean firstVisit = false;
|
if (orgId.equals("47255004333112711A1001")) {
|
firstVisit = true;
|
}
|
if (!firstVisit) {
|
//景宁的不需要将之前的任务停掉，全生成
|
if (endTime1.before(endTime) && serviceSubtask1.getServiceType().equals("2")) {
|
//如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
|
serviceSubtask1.setSendstate(4L);
|
if (StringUtils.isNotEmpty(serviceSubtask.getRemark()))
|
serviceSubtask.setRemark(serviceSubtask.getRemark() + ",科室/病区患者再入院");
|
else serviceSubtask.setRemark("科室/病区患者再入院");
|
serviceSubtask1.setResult("error");
|
serviceSubtask1.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtask1.setUpdateTime(new Date());
|
Boolean aBoolean = serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
|
if (aBoolean) i = 1;
|
} else {
|
//相反,则将当有的数据停掉
|
serviceSubtask.setResult("error");
|
serviceSubtask.setSendstate(4L);
|
if (StringUtils.isNotEmpty(serviceSubtask.getRemark()))
|
serviceSubtask.setRemark(serviceSubtask.getRemark() + ",当前患者出院时间后有待执行的出院随访长期任务");
|
else serviceSubtask.setRemark("当前患者出院时间后有待执行的出院随访长期任务");
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
}
|
}
|
} else if (type == 3) {
|
//type=3 表示疾病
|
//将之前的停掉
|
serviceSubtask1.setSendstate(4L);
|
if (StringUtils.isNotEmpty(serviceSubtask.getRemark()))
|
serviceSubtask.setRemark(serviceSubtask.getRemark() + ",疾病患者再入院");
|
else serviceSubtask.setRemark("疾病患者再入院");
|
serviceSubtask1.setResult("error");
|
// serviceSubtask1.setFinishtime(new Date());
|
serviceSubtask1.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
|
//重新新增子任务
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
//这里需要全失败
|
addServiceSubtaskPreachform(serviceSubtask, "5");
|
|
}
|
}
|
} else {
|
if (StringUtils.isEmpty(serviceSubtask.getPhone())) {
|
if (StringUtils.isNotEmpty(serviceSubtask.getRemark()))
|
serviceSubtask.setRemark(serviceSubtask.getRemark() + ",手机号为空");
|
else serviceSubtask.setRemark("手机号为空");
|
serviceSubtask.setSendstate(4L);
|
serviceSubtask.setResult("error");
|
}
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
addServiceSubtaskPreachform(serviceSubtask, null);
|
}
|
} else if (serviceSubtask.getTaskSituation() != null && serviceSubtask.getTaskSituation() == 6) {
|
//说明该患者是被过滤的，不用再执行了
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
serviceSubtask.setSendstate(4L);
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
} else {
|
if (StringUtils.isEmpty(serviceSubtask.getPhone())) {
|
if (StringUtils.isNotEmpty(serviceSubtask.getRemark()))
|
serviceSubtask.setRemark(serviceSubtask.getRemark() + ",手机号为空");
|
else serviceSubtask.setRemark("手机号为空");
|
serviceSubtask.setSendstate(4L);
|
serviceSubtask.setResult("error");
|
}
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
addServiceSubtaskPreachform(serviceSubtask, null);
|
}
|
|
//将 check_flag 改成 1（已处理）
|
if (i == 1) {
|
PatMedInhosp patMedInhosp2 = new PatMedInhosp();
|
patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
|
if (type == 1) patMedInhosp2.setDeptcheckFlag("1");
|
if (type == 2) patMedInhosp2.setWardcheckFlag("1");
|
if (type == 3) patMedInhosp2.setDiagcheckFlag("1");
|
if (type == 4) patMedInhosp2.setInDeptcheckFlag("1");
|
if (type == 5) patMedInhosp2.setInWardcheckFlag("1");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp2);
|
} else {
|
//生成子任务失败，
|
log.info("生成子任务失败serviceSubtask的taskid为：{},patid为：{}", serviceSubtask.getTaskid(), serviceSubtask.getPatid());
|
PatMedInhosp patMedInhosp2 = new PatMedInhosp();
|
patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
|
if (type == 1) patMedInhosp2.setDeptcheckFlag("2");
|
if (type == 2) patMedInhosp2.setWardcheckFlag("2");
|
if (type == 3) patMedInhosp2.setDiagcheckFlag("2");
|
if (type == 4) patMedInhosp2.setInDeptcheckFlag("2");
|
if (type == 5) patMedInhosp2.setInWardcheckFlag("2");
|
patMedInhosp2.setRemark("生成子任务失败 " + type);
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp2);
|
}
|
} catch (Exception e) {
|
//出错回滚事务
|
log.info("生成子任务报错回滚serviceSubtask的taskid为：{},patid为：{}", serviceSubtask.getTaskid(), serviceSubtask.getPatid());
|
PatMedInhosp patMedInhosp2 = new PatMedInhosp();
|
patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
|
if (type == 1) patMedInhosp2.setDeptcheckFlag("2");
|
if (type == 2) patMedInhosp2.setWardcheckFlag("2");
|
if (type == 3) patMedInhosp2.setDiagcheckFlag("2");
|
if (type == 0) patMedInhosp2.setMedcheckFlag("2");
|
patMedInhosp2.setRemark("生成子任务报错回滚 " + type);
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp2);
|
e.printStackTrace();
|
}
|
}
|
|
|
/**
|
*
|
* @param taskid 任务id
|
* @param check 是否需要校验
|
* @param patMedOperationItem 手术记录
|
* @param config 配置信息 visit.early.day
|
*/
|
//将患者放到subtask中 手术专用
|
private void writeInSubTaskForOp(Long taskid, Boolean check, PatMedOperationItem patMedOperationItem, String config) {
|
String longTaskReason = patMedOperationItem.getLongTaskReason();
|
String orgId = patMedOperationItem.getOrgid();
|
if (StringUtils.isEmpty(longTaskReason)) longTaskReason = "";
|
ServiceTask st = new ServiceTask();
|
st.setTaskid(taskid);
|
st.setSendState(2L);
|
List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);
|
ServiceTask serviceTask = null;
|
if (CollectionUtils.isEmpty(serviceTasks)) {
|
log.info("该手术对应手术等级的长期任务不存在,任务ID为：{}", taskid);
|
patMedOperationItem.setOpercheckFlag("2");
|
patMedOperationItem.setLongTaskReason(" & 该手术对应手术等级的长期任务不存在,任务ID为:" + taskid +";");
|
otherVisitFacade.updateOperationItem(patMedOperationItem);
|
return;
|
} else {
|
serviceTask = serviceTasks.get(0);
|
}
|
if (Objects.isNull(patMedOperationItem.getOplevelcode())) {
|
return;
|
}
|
if (Objects.isNull(patMedOperationItem.getPatid())) {
|
return;
|
}
|
PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedOperationItem.getPatid());
|
if (Objects.isNull(patArchive)) {
|
return;
|
}
|
PatMedInhosp patMedInhosp = new PatMedInhosp();
|
patMedInhosp.setPatid((patMedOperationItem.getPatid()));
|
patMedInhosp.setInhospstate("1");
|
patMedInhosp.setFuflag("1");
|
//手术随访
|
if(!active.equals("hzszlyy")){
|
patMedInhosp.setSerialnum(patMedOperationItem.getSerialnum());
|
}
|
List<PatMedInhosp> patMedInhospList = inhospVisitFacade.selectPatMedInhospList(patMedInhosp);
|
|
if (CollectionUtils.isEmpty(patMedInhospList)) {
|
return;
|
}
|
|
//封装serviceSubtask
|
ServiceSubtask serviceSubtask = boxedServiceSubtaskForOp(serviceTask, patMedInhospList.get(0), patMedOperationItem, patArchive, config);
|
if (ObjectUtils.isEmpty(serviceSubtask) || Objects.isNull(serviceSubtask.getTaskid())) {
|
return;
|
}
|
if (StringUtils.isNotEmpty(patMedOperationItem.getLeaveldeptcode())) {
|
serviceSubtask.setVisitDeptCode(patMedOperationItem.getLeaveldeptcode());
|
serviceSubtask.setVisitDeptName(patMedOperationItem.getLeaveldeptname());
|
} else {
|
serviceSubtask.setVisitDeptCode(patMedOperationItem.getLeavehospitaldistrictcode());
|
serviceSubtask.setVisitDeptName(patMedOperationItem.getLeavehospitaldistrictname());
|
}
|
//记录insertServiceSubtask语句返回状态
|
Integer i = 0;
|
try {
|
//先判断一下，是否需要校验
|
if (check && (Objects.isNull(serviceSubtask.getTaskSituation()) || serviceSubtask.getTaskSituation() != 6)) {
|
//在新增之前，先通过患者ID，sendstate=2查询一下，在所有长期任务中，是不是还有该患者待执行的任务，有的话,比较之前的endtime是否小于当前的endtaime,如果之前的小于现在的，则直接将之前的停掉（原因再入院）
|
ServiceSubtaskEntity subtask = new ServiceSubtaskEntity();
|
subtask.setPatid(patArchive.getId());
|
subtask.setSendstate(2L);
|
subtask.setTaskid(taskid);
|
List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
|
// log.info("该患者待执行的任务:{}", CollectionUtils.isNotEmpty(selectServiceSubtaskList) ? selectServiceSubtaskList.size() : null);
|
if (CollectionUtils.isNotEmpty(selectServiceSubtaskList) && selectServiceSubtaskList.size() > 0) {
|
for (ServiceSubtask serviceSubtask1 : selectServiceSubtaskList) {
|
if (Objects.isNull(serviceSubtask1.getLongSendTime())) {
|
//不是长期任务，不处理
|
continue;
|
}
|
}
|
} else {
|
if (StringUtils.isEmpty(serviceSubtask.getPhone())) {
|
if (StringUtils.isNotEmpty(serviceSubtask.getRemark()))
|
serviceSubtask.setRemark(serviceSubtask.getRemark() + ",手机号为空");
|
else serviceSubtask.setRemark("手机号为空");
|
serviceSubtask.setSendstate(4L);
|
serviceSubtask.setResult("error");
|
}
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
addServiceSubtaskPreachform(serviceSubtask, null);
|
}
|
} else if (serviceSubtask.getTaskSituation() == 6) {
|
//说明该患者是被过滤的，不用再执行了
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
serviceSubtask.setSendstate(4L);
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
} else {
|
if (StringUtils.isEmpty(serviceSubtask.getPhone())) {
|
if (StringUtils.isNotEmpty(serviceSubtask.getRemark()))
|
serviceSubtask.setRemark(serviceSubtask.getRemark() + ",手机号为空");
|
else serviceSubtask.setRemark("手机号为空");
|
serviceSubtask.setSendstate(4L);
|
serviceSubtask.setResult("error");
|
}
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
addServiceSubtaskPreachform(serviceSubtask, null);
|
}
|
|
//将check_flag改成1（已处理）
|
if (i == 1) {
|
PatMedOperationItem patMedOperationItem2 = new PatMedOperationItem();
|
patMedOperationItem2.setId(patMedOperationItem.getId());
|
patMedOperationItem2.setOpercheckFlag("1");
|
otherVisitFacade.updateOperationItem(patMedOperationItem2);
|
} else {
|
//生成子任务失败，
|
log.info("生成子任务失败serviceSubtask的taskid为：{},patid为：{}", serviceSubtask.getTaskid(), serviceSubtask.getPatid());
|
PatMedOperationItem patMedOperationItem2 = new PatMedOperationItem();
|
patMedOperationItem2.setId(patMedOperationItem.getId());
|
patMedOperationItem2.setOpercheckFlag("2");
|
patMedOperationItem2.setLongTaskReason("生成子任务失败 4;");
|
patMedOperationItem2.setUpdateTime(new Date());
|
otherVisitFacade.updateOperationItem(patMedOperationItem2);
|
}
|
} catch (Exception e) {
|
//出错回滚事务
|
|
log.error("生成子任务报错回滚sserviceSubtask的taskid为：{},patid为：{},手术详情ID为：{}",
|
serviceSubtask.getTaskid(), serviceSubtask.getPatid(), patMedOperationItem.getId(), e);
|
PatMedOperationItem patMedOperationItem2 = new PatMedOperationItem();
|
patMedOperationItem2.setId(patMedOperationItem.getId());
|
patMedOperationItem2.setOpercheckFlag("2");
|
patMedOperationItem2.setUpdateTime(new Date());
|
patMedOperationItem2.setLongTaskReason("生成子任务报错回滚 4;");
|
otherVisitFacade.updateOperationItem(patMedOperationItem2);
|
e.printStackTrace();
|
}
|
}
|
|
private Integer addServiceSubtaskPreachform(ServiceSubtask serviceSubtask, String sendstate) {
|
//将preachformDesc的json对象，放到list集合中
|
ServiceTask serviceTask = serviceTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
|
if (Objects.isNull(serviceTask)) {
|
log.error("addServiceSubtaskPreachform taskid={} 查不到任务，跳过preachform子表生成", serviceSubtask.getTaskid());
|
return 0;
|
}
|
String preachformDesc = serviceTask.getPreachformDesc();
|
|
ObjectMapper objectMapper = new ObjectMapper();
|
if (org.apache.commons.lang3.StringUtils.isNotEmpty(preachformDesc)) {
|
List<ServiceSubtaskPreachform> serviceSubtaskPreachformList = null;
|
try {
|
serviceSubtaskPreachformList = objectMapper.readValue(preachformDesc, new TypeReference<List<ServiceSubtaskPreachform>>() {
|
});
|
} catch (JsonProcessingException e) {
|
log.error("preachform转List<ServiceSubtaskPreachform>报错了：{}", e.getMessage());
|
}
|
if (CollectionUtils.isEmpty(serviceSubtaskPreachformList)) {
|
log.error("preachformDesc解析后为空，跳过preachform子表生成，taskid为：{}，preachformDesc为：{}",
|
serviceSubtask.getTaskid(), preachformDesc);
|
return 0;
|
}
|
for (ServiceSubtaskPreachform serviceSubtaskPreachform : serviceSubtaskPreachformList) {
|
serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
|
serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
|
|
//先查询一下，是否存在，如果已经存在，就不新增了
|
List<ServiceSubtaskPreachform> serviceSubtaskPreachformList1 = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(serviceSubtaskPreachform);
|
if (CollectionUtils.isNotEmpty(serviceSubtaskPreachformList1)) continue;
|
|
//这个sendstate需要在数据库设置一个默认值为“1”
|
serviceSubtaskPreachform.setSendstate("1");
|
if (StringUtils.isNotEmpty(sendstate)) serviceSubtaskPreachform.setSendstate(sendstate);
|
|
serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
|
serviceSubtaskPreachformMapper.insertServiceSubtaskPreachform(serviceSubtaskPreachform);
|
}
|
|
}
|
|
return 0;
|
}
|
|
|
//封装serviceSubtask
|
@Override
|
public ServiceSubtask boxedServiceSubtask(ServiceTask serviceTask, PatMedInhosp patMedInhosp1, PatArchive patArchive, String config, Integer type) {
|
//增加serviceTask判空
|
// if(Objects.isNull(serviceTask)){
|
// return null;
|
// }
|
ServiceSubtask serviceSubtask = DtoConversionUtils.sourceToTarget(serviceTask, ServiceSubtask.class);
|
serviceSubtask.setTaskid(serviceTask.getTaskid());
|
serviceSubtask.setOrgid(serviceTask.getOrgid());
|
serviceSubtask.setCampusid(serviceTask.getCampusid());
|
if (StringUtils.isNotEmpty(serviceTask.getLibtemplateid()))
|
serviceSubtask.setLibtemplateid(Long.valueOf(serviceTask.getLibtemplateid()));
|
serviceSubtask.setNurseId(patMedInhosp1.getNurseId());
|
serviceSubtask.setNurseName(patMedInhosp1.getNurseName());
|
serviceSubtask.setInhospid(patMedInhosp1.getInhospid());
|
serviceSubtask.setDrcode(patMedInhosp1.getDrcode());
|
serviceSubtask.setDrname(patMedInhosp1.getDrname());
|
serviceSubtask.setLeaveldeptcode(patMedInhosp1.getLeaveldeptcode());
|
serviceSubtask.setLeaveldeptname(patMedInhosp1.getLeaveldeptname());
|
serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getLeavehospitaldistrictcode());
|
serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());
|
if (type == 4 || type == 5) {
|
//设置入院的
|
serviceSubtask.setLeaveldeptcode(patMedInhosp1.getDeptcode());
|
serviceSubtask.setLeaveldeptname(patMedInhosp1.getDeptname());
|
serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getHospitaldistrictcode());
|
serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getHospitaldistrictname());
|
}
|
serviceSubtask.setLeaveicd10code(patMedInhosp1.getLeaveicd10code());
|
serviceSubtask.setLeavediagname(patMedInhosp1.getLeavediagname());
|
serviceSubtask.setDiagname(patMedInhosp1.getDiagname());
|
serviceSubtask.setTemplateid(serviceTask.getTemplateid());
|
serviceSubtask.setTemplatename(serviceTask.getTemplatename());
|
serviceSubtask.setPatid(patArchive.getId());
|
serviceSubtask.setSendname(patArchive.getName());
|
serviceSubtask.setSfzh(patArchive.getIdcardno());
|
serviceSubtask.setPhone(patArchive.getTelcode());
|
if (StringUtils.isBlank(patArchive.getTelcode())) serviceSubtask.setPhone(patArchive.getRelativetelcode());
|
serviceSubtask.setSex(patArchive.getSex());
|
serviceSubtask.setAge(patArchive.getAge());
|
serviceSubtask.setSendstate(2L);
|
serviceSubtask.setCampusid(patMedInhosp1.getCampusid());
|
serviceSubtask.setManagementDoctor(patMedInhosp1.getManagementDoctor());
|
serviceSubtask.setManagementDoctorCode(patMedInhosp1.getManagementDoctorCode());
|
serviceSubtask.setStarttime(patMedInhosp1.getStarttime());
|
serviceSubtask.setEndtime(patMedInhosp1.getEndtime());
|
serviceSubtask.setServiceType(serviceTask.getServiceType());
|
serviceSubtask.setPreachform(serviceTask.getPreachform());
|
serviceSubtask.setHospType("2");
|
if (type == 4 || type == 5) serviceSubtask.setHospType("6");
|
serviceSubtask.setCreateTime(new Date());
|
serviceSubtask.setUpdateTime(new Date());
|
serviceSubtask.setCreateBy(patMedInhosp1.getNurseName());
|
serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getLeavehospitaldistrictcode());
|
serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());
|
serviceSubtask.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtask.setUpdateTime(new Date());
|
//如果是宣教就设置为7
|
if (serviceTask.getServiceType().equals("17")) serviceSubtask.setTaskSituation(7);
|
//设置发送时间
|
if (serviceTask.getSendDay() == null) serviceTask.setSendDay(1L);
|
Date newDate = null;
|
if (!Objects.isNull(patMedInhosp1.getEndtime())) {
|
newDate = addDays(patMedInhosp1.getEndtime(), serviceTask.getSendDay().intValue());
|
} else {
|
//如果等于4,说明是入院宣教，入院不可能有endTime
|
if (type != 4 && type != 5) {
|
patMedInhosp1.setDeptcheckFlag("2");
|
patMedInhosp1.setRemark(patMedInhosp1.getRemark() + "& 该患者疾病出院时间为空,出院记录ID为:" + patMedInhosp1.getInhospid());
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
//如果出院时间为空，则返回一个新对象
|
return new ServiceSubtask();
|
}
|
//入院宣教，基本当天或隔天就要发出
|
newDate = addDays(new Date(), serviceTask.getSendDay().intValue());
|
}
|
serviceSubtask.setLongSendTime(newDate);
|
serviceSubtask.setVisitTime(newDate);
|
|
// if (patMedInhosp1.getFudate() != null && !patMedInhosp1.getOrgid().equals("47255004333112711A1001")) serviceSubtask.setVisitTime(patMedInhosp1.getFudate());
|
//如果是通知的话，需要提前几天将通过短信发出去（具体几天，这个可以配置在sys_conf表中）
|
if ("3".equals(serviceTask.getType())) {
|
serviceSubtask.setVisitTime(minusDay(newDate, StringUtils.isNotEmpty(config) ? Integer.parseInt(config) : 0));
|
//如果该出院记录有随访时间，则用他自己的随访时间
|
if (patMedInhosp1.getFudate() != null) {
|
serviceSubtask.setVisitTime(minusDay(patMedInhosp1.getFudate(), StringUtils.isNotEmpty(config) ? Integer.parseInt(config) : 0));
|
} else {
|
//判断是不是景宁
|
if (patMedInhosp1.getOrgid().equals("47255004333112711A1001")) {
|
serviceSubtask.setVisitTime(null);
|
//不执行
|
serviceSubtask.setSendstate(4L);
|
serviceSubtask.setRemark("景宁没有给随访时间，不发送通知短信");
|
}
|
}
|
|
}
|
//如果患者的入院和出院时间一致，可以不用随访（南华附一肿瘤一病区提出）
|
if (active.equals("nhfy") && patMedInhosp1.getStarttime() != null && patMedInhosp1.getEndtime() != null && DateUtils.differentDaysByMillisecond(patMedInhosp1.getStarttime(), patMedInhosp1.getEndtime()) == 0) {
|
serviceSubtask.setRemark("患者当天出院，不用随访");
|
serviceSubtask.setResult("error");
|
//不执行
|
serviceSubtask.setSendstate(4L);
|
}
|
|
//患者发送时间
|
if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) {
|
String remark = patArchive.getNotrequiredreason();
|
serviceSubtask.setRemark(remark);
|
serviceSubtask.setResult("error");
|
serviceSubtask.setTaskSituation(6);
|
//不执行
|
serviceSubtask.setSendstate(4L);
|
}
|
return serviceSubtask;
|
}
|
|
//封装serviceSubtask
|
private ServiceSubtask boxedServiceSubtaskForOp(ServiceTask serviceTask, PatMedInhosp patMedInhosp1, PatMedOperationItem patMedOperationItem, PatArchive patArchive, String config) {
|
ServiceSubtask serviceSubtask = DtoConversionUtils.sourceToTarget(serviceTask, ServiceSubtask.class);
|
serviceSubtask.setTaskid(serviceTask.getTaskid());
|
serviceSubtask.setOrgid(serviceTask.getOrgid());
|
serviceSubtask.setCampusid(serviceTask.getCampusid());
|
if (StringUtils.isNotEmpty(serviceTask.getLibtemplateid()))
|
serviceSubtask.setLibtemplateid(Long.valueOf(serviceTask.getLibtemplateid()));
|
serviceSubtask.setNurseId(patMedInhosp1.getNurseId());
|
serviceSubtask.setNurseName(patMedInhosp1.getNurseName());
|
serviceSubtask.setInhospid(patMedInhosp1.getInhospid());
|
serviceSubtask.setDrcode(patMedInhosp1.getDrcode());
|
serviceSubtask.setDrname(patMedInhosp1.getDrname());
|
serviceSubtask.setLeaveldeptcode(patMedInhosp1.getLeaveldeptcode());
|
serviceSubtask.setLeaveldeptname(patMedInhosp1.getLeaveldeptname());
|
serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getLeavehospitaldistrictcode());
|
serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());
|
|
serviceSubtask.setTemplateid(serviceTask.getTemplateid());
|
serviceSubtask.setTemplatename(serviceTask.getTemplatename());
|
serviceSubtask.setPatid(patArchive.getId());
|
serviceSubtask.setSendname(patArchive.getName());
|
serviceSubtask.setSfzh(patArchive.getIdcardno());
|
serviceSubtask.setPhone(patArchive.getTelcode());
|
if (StringUtils.isBlank(patArchive.getTelcode())) serviceSubtask.setPhone(patArchive.getRelativetelcode());
|
serviceSubtask.setSex(patArchive.getSex());
|
serviceSubtask.setAge(patArchive.getAge());
|
serviceSubtask.setSendstate(2L);
|
serviceSubtask.setManagementDoctor(patMedInhosp1.getDrname());
|
serviceSubtask.setManagementDoctorCode(patMedInhosp1.getDrcode());
|
|
serviceSubtask.setStarttime(patMedInhosp1.getStarttime());
|
serviceSubtask.setEndtime(patMedInhosp1.getEndtime());
|
|
serviceSubtask.setServiceType(serviceTask.getServiceType());
|
serviceSubtask.setPreachform(serviceTask.getPreachform());
|
serviceSubtask.setHospType("2");
|
serviceSubtask.setCreateTime(new Date());
|
serviceSubtask.setUpdateTime(new Date());
|
serviceSubtask.setCreateBy(patMedInhosp1.getNurseName());
|
serviceSubtask.setOperationItemId(patMedOperationItem.getId());
|
serviceSubtask.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtask.setUpdateTime(new Date());
|
|
//设置发送时间
|
if (serviceTask.getSendDay() == null) serviceTask.setSendDay(1L);
|
Date newDate = null;
|
if (!Objects.isNull(patMedInhosp1.getEndtime())) {
|
newDate = addDays(patMedInhosp1.getEndtime(), serviceTask.getSendDay().intValue());
|
} else {
|
patMedOperationItem.setOpercheckFlag("2");
|
patMedOperationItem.setLongTaskReason("该患者手术出院时间为空,手术详情ID为:" + patMedOperationItem.getId() + ";");
|
otherVisitFacade.updateOperationItem(patMedOperationItem);
|
// patMedInhosp1.setDeptcheckFlag("2");
|
// patMedInhosp1.setRemark(patMedInhosp1.getRemark() + "& 该患者手术出院时间为空,出院记录ID为:" + patMedInhosp1.getInhospid());
|
// inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
//如果出院时间为空，则返回一个新对象
|
return null;
|
}
|
serviceSubtask.setLongSendTime(newDate);
|
serviceSubtask.setVisitTime(newDate);
|
|
//如果是通知的话，需要提前几天将通过短信发出去（具体几天，这个可以配置在sys_conf表中）
|
if ("3".equals(serviceTask.getType())) {
|
serviceSubtask.setVisitTime(minusDay(newDate, StringUtils.isNotEmpty(config) ? Integer.parseInt(config) : 0));
|
}
|
//患者发送时间
|
if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) {
|
String remark = patArchive.getNotrequiredreason();
|
serviceSubtask.setRemark(remark);
|
serviceSubtask.setResult("error");
|
serviceSubtask.setTaskSituation(6);
|
//不执行
|
serviceSubtask.setSendstate(4L);
|
}
|
return serviceSubtask;
|
}
|
|
/**
|
* 减去相应天数
|
*
|
* @param originalDate
|
* @param day
|
* @return
|
*/
|
public Date minusDay(Date originalDate, Integer day) {
|
// 1. 将 Date 转换为 Instant
|
Instant instant = originalDate.toInstant();
|
|
// 2. 在 Instant 上减去2天
|
Instant twoDaysAgoInstant = instant.minus(2, ChronoUnit.DAYS);
|
|
// 3. 将计算后的 Instant 转回 Date
|
return Date.from(twoDaysAgoInstant);
|
}
|
|
//处理入院信息
|
private void dealInHospInfo(List<PatMedInhosp> patMedInhospList) {
|
for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
|
try {
|
//获取当前入院患者的待执行的出院子任务随访信息
|
ServiceSubtaskEntity subtask = new ServiceSubtaskEntity();
|
subtask.setPatid(patMedInhosp1.getPatid());
|
subtask.setSendstate(2L);
|
List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
|
// log.error("入院的患者待执行的任务:{}", selectServiceSubtaskList);
|
if (CollectionUtils.isNotEmpty(selectServiceSubtaskList)) {
|
for (ServiceSubtask serviceSubtask1 : selectServiceSubtaskList) {
|
if (Objects.isNull(serviceSubtask1.getLongSendTime())) {
|
//不是长期任务，不处理
|
continue;
|
}
|
//景宁 出院首次（7天）随访一定要做
|
boolean firstVisit = false;
|
if (serviceSubtask1.getOrgid().equals("47255004333112711A1001")) {
|
firstVisit = true;
|
}
|
if (!firstVisit) {
|
if (serviceSubtask1.getEndtime().before(patMedInhosp1.getStarttime())) {
|
//如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
|
// log.error("患者再入院的serviceSubtask1为:{}", serviceSubtask1);
|
serviceSubtask1.setSendstate(4L);
|
serviceSubtask1.setIsVisitAgain(2);
|
serviceSubtask1.setRemark("患者再入院");
|
serviceSubtask1.setResult("error");
|
serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
|
}
|
}
|
|
}
|
}
|
} catch (Exception e) {
|
log.error("入院数据信息出异常了：{},{}", patMedInhosp1, e.getMessage());
|
}
|
}
|
}
|
|
/**
|
* 统一更新pat_med_inhosp的check_flag
|
*
|
* @param patMedInhosp 患者住院记录
|
* @param type 1=deptcheck_flag, 2=wardcheck_flag, 3=diagcheck_flag, 4=inDeptcheck_flag, 5=inWardcheck_flag
|
* @param flagValue 要设置的值
|
* @param remark 备注信息
|
*/
|
private void updateCheckFlag(PatMedInhosp patMedInhosp, Integer type, String flagValue, String remark) {
|
PatMedInhosp updateObj = new PatMedInhosp();
|
updateObj.setInhospid(patMedInhosp.getInhospid());
|
switch (type) {
|
case 1:
|
updateObj.setDeptcheckFlag(flagValue);
|
break;
|
case 2:
|
updateObj.setWardcheckFlag(flagValue);
|
break;
|
case 3:
|
updateObj.setDiagcheckFlag(flagValue);
|
break;
|
case 4:
|
updateObj.setInDeptcheckFlag(flagValue);
|
break;
|
case 5:
|
updateObj.setInWardcheckFlag(flagValue);
|
break;
|
}
|
if (StringUtils.isNotEmpty(remark)) {
|
updateObj.setRemark(remark + " (type=" + type + ")");
|
}
|
inhospVisitFacade.updatePatMedInhosp(updateObj);
|
}
|
|
/**
|
* 基于规则的任务生成方法
|
* 根据患者离院科室或病区查询service_task_rule，获取deptRule、wradRule、diagRule
|
* 根据规则值决定调用哪个方法生成随访任务
|
*/
|
private void addSubTaskByRule(String config, List<PatMedInhosp> patMedInhosps) {
|
for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
|
// 获取患者基本信息
|
PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
|
if (Objects.isNull(patArchive)) {
|
patMedInhosp1.setDeptcheckFlag("2");
|
patMedInhosp1.setLongTaskReason("患者基本信息为空");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
continue;
|
}
|
|
try {
|
// 查询规则：根据离院科室或病区
|
ServiceTaskRule ruleQuery = new ServiceTaskRule();
|
ruleQuery.setDeptcode(patMedInhosp1.getLeaveldeptcode());
|
ruleQuery.setWardcode(patMedInhosp1.getLeavehospitaldistrictcode());
|
ServiceTaskRule rule = serviceTaskRuleMapper.selectServiceTaskRuleByDeptOrWard(ruleQuery);
|
|
if (rule == null) {
|
// 规则为空，全部生成
|
log.info("【基于规则】患者{}未配置规则，执行全部生成逻辑", patMedInhosp1.getInhospid());
|
addDeptSubTaskForPatient(patMedInhosp1, patArchive, config);
|
if (!active.equals("xh")) {
|
addWardSubTaskForPatient(patMedInhosp1, patArchive, config);
|
addIcd10SubTaskForPatient(patMedInhosp1, patArchive, config);
|
}
|
} else {
|
// 有规则，按规则执行
|
log.info("【基于规则】患者{}查询到规则：deptRule={}, wradRule={}, diagRule={}", patMedInhosp1.getInhospid(), rule.getDeptRule(), rule.getWradRule(), rule.getDiagRule());
|
|
boolean deptIsPrimary = "1".equals(rule.getDeptRule());
|
boolean wardIsPrimary = "1".equals(rule.getWradRule());
|
boolean diagIsPrimary = "1".equals(rule.getDiagRule());
|
boolean deptIsSecondary = "2".equals(rule.getDeptRule());
|
boolean wardIsSecondary = "2".equals(rule.getWradRule());
|
boolean diagIsSecondary = "2".equals(rule.getDiagRule());
|
|
boolean hasPrimaryRule = deptIsPrimary || wardIsPrimary || diagIsPrimary;
|
|
if (hasPrimaryRule) {
|
// 第一步：执行所有规则=1的方法，每个独立记录成功/失败
|
int deptGenCount = 0;
|
int wardGenCount = 0;
|
int diagGenCount = 0;
|
|
if (deptIsPrimary) {
|
log.info("【基于规则】执行科室首要规则");
|
deptGenCount = addDeptSubTaskForPatient(patMedInhosp1, patArchive, config);
|
}
|
|
if (!active.equals("xh")) {
|
if (wardIsPrimary) {
|
log.info("【基于规则】执行病区首要规则");
|
wardGenCount = addWardSubTaskForPatient(patMedInhosp1, patArchive, config);
|
}
|
|
if (diagIsPrimary) {
|
log.info("【基于规则】执行疾病首要规则");
|
diagGenCount = addIcd10SubTaskForPatient(patMedInhosp1, patArchive, config);
|
}
|
}
|
|
int primaryGeneratedCount = deptGenCount + wardGenCount + diagGenCount;
|
log.info("【基于规则】首要规则执行结果: deptGen={}, wardGen={}, diagGen={}, total={}", deptGenCount, wardGenCount, diagGenCount, primaryGeneratedCount);
|
|
String remark = patMedInhosp1.getRemark();
|
// 第二步：判断首要规则是否有任意一个生成成功
|
if (primaryGeneratedCount > 0) {
|
// 至少有一个首要规则生成成功
|
// —— 将=2的次要规则对应flag设为"2"（跳过）
|
log.info("【基于规则】首要规则有成功(count={})，将次要规则对应flag设为2", primaryGeneratedCount);
|
if (deptIsSecondary) {
|
updateCheckFlag(patMedInhosp1, 1, "2", StringUtils.isNotEmpty(remark) ? remark + ";首要规则已生成，次要规则跳过" : "首要规则已生成，次要规则跳过");
|
}
|
if (!active.equals("xh")) {
|
if (wardIsSecondary) {
|
updateCheckFlag(patMedInhosp1, 2, "2", StringUtils.isNotEmpty(remark) ? remark + ";首要规则已生成，次要规则跳过" : "首要规则已生成，次要规则跳过");
|
}
|
if (diagIsSecondary) {
|
updateCheckFlag(patMedInhosp1, 3, "2", StringUtils.isNotEmpty(remark) ? remark + ";首要规则已生成，次要规则跳过" : "首要规则已生成，次要规则跳过");
|
}
|
}
|
// —— 对于=1且生成成功的，将其对应flag设为"1"
|
if (deptIsPrimary && deptGenCount > 0) {
|
updateCheckFlag(patMedInhosp1, 1, "1", StringUtils.isNotEmpty(remark) ? remark + ";科室首要规则生成成功" : "科室首要规则生成成功");
|
}
|
if (!active.equals("xh")) {
|
if (wardIsPrimary && wardGenCount > 0) {
|
updateCheckFlag(patMedInhosp1, 2, "1", StringUtils.isNotEmpty(remark) ? remark + ";病区首要规则生成成功" : "病区首要规则生成成功");
|
}
|
if (diagIsPrimary && diagGenCount > 0) {
|
updateCheckFlag(patMedInhosp1, 3, "1", StringUtils.isNotEmpty(remark) ? remark + ";疾病首要规则生成成功" : "疾病首要规则生成成功");
|
}
|
}
|
// —— 对于=1但生成失败的，将其对应flag设为"2"
|
if (deptIsPrimary && deptGenCount == 0) {
|
updateCheckFlag(patMedInhosp1, 1, "2", StringUtils.isNotEmpty(remark) ? remark + ";科室首要规则生成失败" : "科室首要规则生成失败");
|
}
|
if (!active.equals("xh")) {
|
if (wardIsPrimary && wardGenCount == 0) {
|
updateCheckFlag(patMedInhosp1, 2, "2", StringUtils.isNotEmpty(remark) ? remark + ";病区首要规则生成失败" : "病区首要规则生成失败");
|
}
|
if (diagIsPrimary && diagGenCount == 0) {
|
updateCheckFlag(patMedInhosp1, 3, "2", StringUtils.isNotEmpty(remark) ? remark + ";疾病首要规则生成失败" : "疾病首要规则生成失败");
|
}
|
}
|
} else {
|
// 所有首要规则全部失败，将=1的flag设为"2"，然后执行=2的方法
|
log.info("【基于规则】首要规则全部失败，将=1的flag设为2，开始执行次要规则");
|
if (deptIsPrimary) {
|
updateCheckFlag(patMedInhosp1, 1, "2", StringUtils.isNotEmpty(remark) ? remark + ";科室首要规则全部失败" : "科室首要规则全部失败");
|
}
|
if (!active.equals("xh")) {
|
if (wardIsPrimary) {
|
updateCheckFlag(patMedInhosp1, 2, "2", StringUtils.isNotEmpty(remark) ? remark + ";病区首要规则全部失败" : "病区首要规则全部失败");
|
}
|
if (diagIsPrimary) {
|
updateCheckFlag(patMedInhosp1, 3, "2", StringUtils.isNotEmpty(remark) ? remark + ";疾病首要规则全部失败" : "疾病首要规则全部失败");
|
}
|
}
|
// 执行次要规则(=2)的方法
|
if (deptIsSecondary) {
|
log.info("【基于规则】执行科室次要规则");
|
addDeptSubTaskForPatient(patMedInhosp1, patArchive, config);
|
}
|
|
if (!active.equals("xh")) {
|
if (wardIsSecondary) {
|
log.info("【基于规则】执行病区次要规则");
|
addWardSubTaskForPatient(patMedInhosp1, patArchive, config);
|
}
|
|
if (diagIsSecondary) {
|
log.info("【基于规则】执行疾病次要规则");
|
addIcd10SubTaskForPatient(patMedInhosp1, patArchive, config);
|
}
|
}
|
}
|
} else {
|
// 没有首要规则（都是"2"或其他），全部生成
|
log.info("【基于规则】无首要规则，执行全部生成逻辑");
|
addDeptSubTaskForPatient(patMedInhosp1, patArchive, config);
|
if (!active.equals("xh")) {
|
addWardSubTaskForPatient(patMedInhosp1, patArchive, config);
|
addIcd10SubTaskForPatient(patMedInhosp1, patArchive, config);
|
}
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
log.error("【基于规则】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
|
patMedInhosp1.setDeptcheckFlag("2");
|
patMedInhosp1.setLongTaskReason("基于规则处理异常");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
}
|
}
|
}
|
|
/**
|
* 为单个患者生成科室维度的子任务
|
*
|
* @return 生成的子任务数量
|
*/
|
private int addDeptSubTaskForPatient(PatMedInhosp patMedInhosp1, PatArchive patArchive, String config) {
|
int generatedCount = 0;
|
try {
|
//根据患者所在科室，获取该科室的长期任务
|
ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
|
serviceTaskdept.setLongtask(1L);
|
serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
|
serviceTaskdept.setDeptType("1");
|
serviceTaskdept.setServiceType("2");
|
serviceTaskdept.setOrgid(patMedInhosp1.getOrgid());
|
List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
|
|
if (CollectionUtils.isEmpty(serviceTaskdepts)) {
|
PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
|
patMedInhosp1.setDeptcheckFlag("2");
|
patMedInhosp1.setWardcheckFlag(patMedInhosp.getWardcheckFlag());
|
patMedInhosp1.setDiagcheckFlag(patMedInhosp.getDiagcheckFlag());
|
patMedInhosp1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在科室未配置离院长期任务;");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
} else {
|
for (ServiceTaskdept serviceTaskdept1 : serviceTaskdepts) {
|
writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 1, config);
|
generatedCount++;
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
log.error("【科室任务】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
|
patMedInhosp1.setDeptcheckFlag("2");
|
patMedInhosp1.setLongTaskReason("科室任务处理异常");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
}
|
return generatedCount;
|
}
|
|
/**
|
* 为单个患者生成病区维度的子任务
|
*
|
* @return 生成的子任务数量
|
*/
|
private int addWardSubTaskForPatient(PatMedInhosp patMedInhosp1, PatArchive patArchive, String config) {
|
int generatedCount = 0;
|
try {
|
String errorreason = null;
|
List<ServiceTaskdept> serviceTaskdeptList = null;
|
if (!StringUtils.isEmpty(patMedInhosp1.getLeavehospitaldistrictcode())) {
|
ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
|
serviceTaskdept.setLongtask(1L);
|
serviceTaskdept.setDeptCode(patMedInhosp1.getLeavehospitaldistrictcode());
|
serviceTaskdept.setDeptType("2");
|
serviceTaskdept.setServiceType("2");
|
serviceTaskdept.setOrgid(patMedInhosp1.getOrgid());
|
serviceTaskdeptList = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
|
if (CollectionUtils.isEmpty(serviceTaskdeptList)) {
|
errorreason = "该患者所在病区未配置长期任务;";
|
}
|
} else {
|
errorreason = "离院病区为空;";
|
}
|
|
if (StringUtils.isNotEmpty(errorreason)) {
|
PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
|
patMedInhosp1.setWardcheckFlag("2");
|
patMedInhosp1.setDeptcheckFlag(patMedInhosp.getDeptcheckFlag());
|
patMedInhosp1.setDiagcheckFlag(patMedInhosp.getDiagcheckFlag());
|
patMedInhosp1.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorreason : errorreason);
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
} else {
|
for (ServiceTaskdept serviceTaskdept1 : serviceTaskdeptList) {
|
writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 2, config);
|
generatedCount++;
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
log.error("【病区任务】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
|
patMedInhosp1.setWardcheckFlag("2");
|
patMedInhosp1.setLongTaskReason("病区任务处理异常");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
}
|
return generatedCount;
|
}
|
|
/**
|
* 为单个患者生成疾病维度的子任务
|
*
|
* @return 生成的子任务数量
|
*/
|
private int addIcd10SubTaskForPatient(PatMedInhosp patMedInhosp1, PatArchive patArchive, String config) {
|
int generatedCount = 0;
|
try {
|
if (StringUtils.isEmpty(patMedInhosp1.getLeaveicd10code())) {
|
return 0;
|
}
|
|
ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
|
serviceTaskdiag.setLongtask(1L);
|
// serviceTaskdiag.setServiceType("2");
|
if (active.equals("nhfy")) {
|
serviceTaskdiag.setIcd10name(patMedInhosp1.getLeavediagname());
|
if (StringUtils.isEmpty(patMedInhosp1.getLeavediagname())) {
|
PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
|
patMedInhosp1.setDiagcheckFlag("2");
|
patMedInhosp1.setLongTaskReason("该患者主诊断名称为空;");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
return 0;
|
}
|
} else {
|
serviceTaskdiag.setIcd10code(patMedInhosp1.getLeaveicd10code());
|
}
|
serviceTaskdiag.setOrgid(patMedInhosp1.getOrgid());
|
List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagListByIcdName(serviceTaskdiag);
|
|
if (CollectionUtils.isEmpty(serviceTaskdiags)) {
|
PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
|
patMedInhosp.setDiagcheckFlag("2");
|
patMedInhosp.setLongTaskReason("该患者所患疾病未配置长期任务;");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp);
|
} else {
|
int flag = 0;
|
for (ServiceTaskdiag serviceTaskdiag1 : serviceTaskdiags) {
|
if (StringUtils.isNotEmpty(serviceTaskdiag1.getDeptCode()) && serviceTaskdiag1.getDeptCode().equals(patMedInhosp1.getLeaveldeptcode())) {
|
writeInSubTask(serviceTaskdiag1.getTaskId(), true, patMedInhosp1, patArchive, 3, config);
|
generatedCount++;
|
flag = 1;
|
} else if (StringUtils.isNotEmpty(serviceTaskdiag1.getWardCode()) && serviceTaskdiag1.getWardCode().equals(patMedInhosp1.getLeavehospitaldistrictcode())) {
|
writeInSubTask(serviceTaskdiag1.getTaskId(), true, patMedInhosp1, patArchive, 3, config);
|
generatedCount++;
|
flag = 1;
|
}
|
}
|
if (flag == 0) {
|
log.error("该科室或病区对于患者所患疾病未配置长期任务,患者：{}", patMedInhosp1.getInhospid());
|
PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
|
patMedInhosp.setDiagcheckFlag("2");
|
patMedInhosp.setLongTaskReason("该科室或病区对于患者所患疾病未配置长期任务;");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp);
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
log.error("【疾病任务】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
|
patMedInhosp1.setDiagcheckFlag("2");
|
patMedInhosp1.setLongTaskReason("疾病任务处理异常");
|
inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
|
}
|
return generatedCount;
|
}
|
|
}
|
