package com.smartor.service.impl;
|
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.fasterxml.jackson.core.type.TypeReference;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.ruoyi.common.core.domain.entity.SysDept;
|
import com.ruoyi.common.utils.DateUtils;
|
import com.ruoyi.common.utils.DtoConversionUtils;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.smartor.domain.*;
|
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 java.time.Instant;
|
import java.time.temporal.ChronoUnit;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 患者住院记录Service业务层处理
|
*
|
* @author smartor
|
* @date 2023-03-04
|
*/
|
@Slf4j
|
@Service
|
public class PatMedInhospServiceImpl implements IPatMedInhospService {
|
@Autowired
|
private PatMedInhospMapper patMedInhospMapper;
|
|
@Autowired
|
private ServiceTaskdeptMapper serviceTaskdeptMapper;
|
|
@Autowired
|
private ServiceTaskdiagMapper serviceTaskdiagMapper;
|
|
@Autowired
|
private PatArchiveMapper patArchiveMapper;
|
@Autowired
|
private PatArchiveImportMapper patArchiveImportMapper;
|
@Autowired
|
private ServiceTaskMapper serviceTaskMapper;
|
@Autowired
|
private ServiceSubtaskMapper serviceSubtaskMapper;
|
@Autowired
|
private ServiceSubtaskPreachformMapper serviceSubtaskPreachformMapper;
|
|
@Value("${spring.profiles.active}")
|
private String active;
|
|
|
/**
|
* 查询患者住院记录
|
*
|
* @param inhospid 患者住院记录主键
|
* @return 患者住院记录
|
*/
|
@Override
|
public PatMedInhosp selectPatMedInhospByInhospid(Long inhospid) {
|
return patMedInhospMapper.selectPatMedInhospByInhospid(inhospid);
|
}
|
|
/**
|
* 查询患者住院记录列表
|
*
|
* @param patMedInhosp 患者住院记录
|
* @return 患者住院记录
|
*/
|
@Override
|
public List<PatMedInhosp> selectPatMedInhospList(PatMedInhosp patMedInhosp) {
|
List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
|
for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
|
String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
|
patMedInhosp1.setTagname(tagname);
|
}
|
return patMedInhospList;
|
}
|
|
@Override
|
public Map<String, Integer> queryPersonCount(PatServiceCount patServiceCount) {
|
if (patServiceCount.getInterval() == 1) {
|
//周
|
} else if (patServiceCount.getInterval() == 2) {
|
//月
|
} else if (patServiceCount.getInterval() == 3) {
|
//年
|
}
|
|
return null;
|
}
|
|
/**
|
* 查询当前登陆人自己（病区、部门）的患者住院记录列表
|
*
|
* @param patMedInhospVO
|
* @return
|
*/
|
public List<PatMedInhosp> selectPatMedInhospListByCondition(PatMedInhospVO patMedInhospVO) {
|
return patMedInhospMapper.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 patMedReq
|
* @return
|
*/
|
@Override
|
public PatMedRes selectPatMedInhospListCount(PatMedReq patMedReq) {
|
PatMedRes patMedRes = null;
|
// 获取当前登陆人的部门权限
|
if (org.springframework.util.CollectionUtils.isEmpty(patMedReq.getDeptcodeList())) {
|
// Long userId = SecurityUtils.getUserId();
|
// List<SysDept> sysDepts = sysUserDeptMapper.selectDeptListByUserId(userId);
|
// List<String> deptCode = new ArrayList<>();
|
// for (SysDept sysDept : sysDepts) {
|
// deptCode.add(sysDept.getDeptId().toString());
|
// }
|
// patMedReq.setDeptcodeList(deptCode);
|
// patMedRes = patMedInhospMapper.selectPatMedInhospCount(patMedReq);
|
}
|
patMedRes = patMedInhospMapper.selectPatMedInhospCount(patMedReq);
|
return patMedRes;
|
}
|
|
/**
|
* 新增患者住院记录
|
*
|
* @param patMedInhosp 患者住院记录
|
* @return 结果
|
*/
|
@Override
|
public int insertPatMedInhosp(PatMedInhosp patMedInhosp) {
|
patMedInhosp.setCreateTime(DateUtils.getNowDate());
|
patMedInhosp.setUpdateTime(DateUtils.getNowDate());
|
return patMedInhospMapper.insertPatMedInhosp(patMedInhosp);
|
}
|
|
/**
|
* 修改患者住院记录
|
*
|
* @param patMedInhosp 患者住院记录
|
* @return 结果
|
*/
|
@Override
|
public int updatePatMedInhosp(PatMedInhosp patMedInhosp) {
|
patMedInhosp.setUpdateTime(DateUtils.getNowDate());
|
return patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
|
}
|
|
/**
|
* 批量删除患者住院记录
|
*
|
* @param inhospids 需要删除的患者住院记录主键
|
* @return 结果
|
*/
|
@Override
|
public int deletePatMedInhospByInhospids(Long[] inhospids) {
|
return patMedInhospMapper.deletePatMedInhospByInhospids(inhospids);
|
}
|
|
/**
|
* 删除患者住院记录信息
|
*
|
* @param inhospid 患者住院记录主键
|
* @return 结果
|
*/
|
@Override
|
public int deletePatMedInhospByInhospid(Long inhospid) {
|
return patMedInhospMapper.deletePatMedInhospByInhospid(inhospid);
|
}
|
|
/**
|
* 删除患者住院记录信息
|
*
|
* @param inhospno 患者住院编码
|
* @return 结果
|
*/
|
@Override
|
public int deletePatMedInhospByInhospno(String inhospno) {
|
return patMedInhospMapper.deletePatMedInhospByInhospno(inhospno);
|
}
|
|
@Override
|
public int dealOutHospInfo() {
|
|
PatMedInhosp pmks = new PatMedInhosp();
|
//获取需要出院部门随访，未处理的数据
|
pmks.setDeptcheckFlag("0");
|
pmks.setInhospstate("1");
|
pmks.setFuflag("1");
|
List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(pmks);
|
log.info("dealOutHospInfo需要处理的出院部门患者信息：{}", patMedInhosps);
|
for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
|
String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
|
patMedInhosp1.setTagname(tagname);
|
}
|
|
//科室
|
for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
|
//获取患者信息
|
PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
|
if (Objects.isNull(patArchive)) {
|
patMedInhosp1.setDeptcheckFlag("2");
|
patMedInhosp1.setLongTaskReason("患者基本信息为空");
|
patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
continue;
|
}
|
try {
|
//根据患者所在科室，获取该科室的长期任务
|
ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
|
serviceTaskdept.setLongtask(1L);
|
serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
|
serviceTaskdept.setDeptType("1");
|
serviceTaskdept.setOrgid(patMedInhosp1.getOrgid());
|
List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
|
//如果部门模板为空（将deptIsNull设置为true）
|
if (CollectionUtils.isEmpty(serviceTaskdepts) || serviceTaskdepts.size() == 0) {
|
PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
|
patMedInhosp1.setDeptcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在科室未配置长期任务;");
|
patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
} else {
|
for (ServiceTaskdept serviceTaskdept1 : serviceTaskdepts) {
|
writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 1);
|
}
|
patMedInhosp1.setDeptcheckFlag("1");
|
patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
}
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
log.error("人员处理出异常了：{}", e.getMessage());
|
}
|
}
|
|
//根据患者所在病区，获取该病区的长期任务,新华医院可以先不用根据病区和疾病来做
|
if (active.equals("xh")) {
|
PatMedInhosp pmbq = new PatMedInhosp();
|
//获取需要出院部门随访，未处理的数据
|
pmbq.setWardcheckFlag("0");
|
pmbq.setInhospstate("1");
|
pmbq.setFuflag("1");
|
List<PatMedInhosp> patMedInhospBQs = patMedInhospMapper.selectPatMedInhospList(pmbq);
|
log.info("dealOutHospInfo需要处理的出院病区患者信息：{}", patMedInhosps);
|
for (PatMedInhosp patMedInhosp1 : patMedInhospBQs) {
|
String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
|
patMedInhosp1.setTagname(tagname);
|
}
|
|
//病区数据处理
|
for (PatMedInhosp pmiBQ1 : patMedInhospBQs) {
|
//获取患者信息
|
PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(pmiBQ1.getPatid());
|
if (Objects.isNull(patArchive)) {
|
pmiBQ1.setWardcheckFlag("2");
|
pmiBQ1.setLongTaskReason("患者基本信息为空");
|
patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
|
continue;
|
}
|
try {
|
ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
|
serviceTaskdept.setLongtask(1L);
|
serviceTaskdept.setDeptCode(pmiBQ1.getLeavehospitaldistrictcode());
|
serviceTaskdept.setDeptType("2");
|
serviceTaskdept.setOrgid(pmiBQ1.getOrgid());
|
List<ServiceTaskdept> serviceTaskdeptList = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
|
//如果部门模板为空（将deptIsNull设置为true）
|
if (CollectionUtils.isEmpty(serviceTaskdeptList) || serviceTaskdeptList.size() == 0) {
|
PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiBQ1.getInhospid());
|
pmiBQ1.setWardcheckFlag("2");
|
pmiBQ1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在病区未配置长期任务;");
|
patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
|
} else {
|
for (ServiceTaskdept serviceTaskdept1 : serviceTaskdeptList) {
|
writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiBQ1, patArchive, 2);
|
}
|
pmiBQ1.setWardcheckFlag("1");
|
patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
|
}
|
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
log.error("人员处理出异常了：{}", e.getMessage());
|
}
|
}
|
|
PatMedInhosp pmjb = new PatMedInhosp();
|
//获取需要出院疾病随访，未处理的数据
|
pmjb.setDiagcheckFlag("0");
|
pmjb.setInhospstate("1");
|
pmjb.setFuflag("1");
|
List<PatMedInhosp> patMedInhospJBs = patMedInhospMapper.selectPatMedInhospList(pmjb);
|
log.info("dealOutHospInfo需要处理的出院疾病患者信息：{}", patMedInhosps);
|
for (PatMedInhosp patMedInhosp1 : patMedInhospJBs) {
|
String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
|
patMedInhosp1.setTagname(tagname);
|
}
|
|
for (PatMedInhosp pmiJB : patMedInhospJBs) {
|
//获取患者信息
|
PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(pmiJB.getPatid());
|
if (Objects.isNull(patArchive)) {
|
pmiJB.setDiagcheckFlag("2");
|
pmiJB.setLongTaskReason("患者基本信息为空");
|
patMedInhospMapper.updatePatMedInhosp(pmiJB);
|
continue;
|
}
|
try {
|
if (StringUtils.isEmpty(pmiJB.getLeaveicd10code())) {
|
continue;
|
}
|
// 根据患者的疾病，获取该疾病的长期任务
|
ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
|
serviceTaskdiag.setLongtask(1L);
|
serviceTaskdiag.setIcd10code(pmiJB.getLeaveicd10code());
|
serviceTaskdiag.setOrgid(pmiJB.getOrgid());
|
|
List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagList(serviceTaskdiag);
|
//如果部门模板为空（将deptIsNull设置为true）
|
if (CollectionUtils.isEmpty(serviceTaskdiags) || serviceTaskdiags.size() == 0) {
|
PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
|
pmiJB.setDiagcheckFlag("2");
|
pmiJB.setLongTaskReason(patMedInhosp.getLongTaskReason() + "所患的疾病未配置长期任务;");
|
patMedInhospMapper.updatePatMedInhosp(pmiJB);
|
} else {
|
for (ServiceTaskdiag serviceTaskdept1 : serviceTaskdiags) {
|
writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiJB, patArchive, 3);
|
}
|
pmiJB.setDiagcheckFlag("1");
|
patMedInhospMapper.updatePatMedInhosp(pmiJB);
|
}
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
log.error("人员处理出异常了：{}", e.getMessage());
|
}
|
}
|
}
|
|
//获取未处理在院的数据(如果刚刚出院的患者数据的出院时间,在下面查询出的入院时间之前,那之前的出院患者的数据,也得停掉,因为又入院了)
|
PatMedInhosp patMedInhosp = new PatMedInhosp();
|
//获取需要出院部门随访，未处理的数据
|
patMedInhosp.setDeptcheckFlag("0");
|
patMedInhosp.setInhospstate("0");
|
List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
|
if (CollectionUtils.isNotEmpty(patMedInhospList) && patMedInhospList.size() > 0) {
|
dealInHospInfo(patMedInhospList);
|
}
|
return 1;
|
}
|
|
//
|
// @Override
|
// public int dealOutHospInfo() {
|
// PatMedInhosp patMedInhosp = new PatMedInhosp();
|
// //获取需要出院部门随访，未处理的数据
|
// patMedInhosp.setDeptcheckFlag("0");
|
// patMedInhosp.setInhospstate("1");
|
// patMedInhosp.setFuflag("1");
|
// List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
|
// log.error("dealOutHospInfo需要处理的出院患者信息：{}", patMedInhosps);
|
// for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
|
// String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
|
// patMedInhosp1.setTagname(tagname);
|
// }
|
//
|
// for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
|
// //先根据科室去service_check查询check_visit_flag是根据“科室”随访，还是根据“第一诊断”随访
|
// ServiceCheck serviceCheck = new ServiceCheck();
|
// serviceCheck.setDeptCode(patMedInhosp1.getDeptcode());
|
// serviceCheck.setOrgid(patMedInhosp1.getOrgid());
|
// List<ServiceCheck> serviceChecks = serviceCheckMapper.selectServiceCheckList(serviceCheck);
|
// //获取患者信息
|
// PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
|
// if (Objects.isNull(patArchive)) {
|
// patMedInhosp1.setDeptcheckFlag("2");
|
// patMedInhosp1.setLongTaskReason("患者基本信息为空");
|
// patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
// continue;
|
// }
|
// try {
|
// if (CollectionUtils.isEmpty(serviceChecks) || serviceChecks != null && serviceChecks.get(0).getCheckVisitFlag() == 1 || serviceChecks != null && serviceChecks.get(0).getCheckVisitFlag() == 3) {
|
// //根据患者所在科室，获取该科室的长期任务
|
// ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
|
// serviceTaskdept.setLongtask(1L);
|
// serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
|
// serviceTaskdept.setServiceType("2");
|
// List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
|
// //如果部门模板为空（暂定，将出入院表的check_flag设置为2 ，long_task_reason 记录原因）
|
// if (CollectionUtils.isEmpty(serviceTaskdepts) || serviceTaskdepts.size() == 0) {
|
// patMedInhosp1.setDeptcheckFlag("2");
|
// patMedInhosp1.setLongTaskReason("该患者所在科室，未配置长期任务;");
|
// patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
// continue;
|
// } else if (serviceTaskdepts.size() > 1) {
|
// //如果查询出多个任务，那就取第一个，并在患者备注一下
|
// List<Long> tempList = serviceTaskdepts.stream().map(ServiceTaskdept::getTaskId).collect(Collectors.toList());
|
// patMedInhosp1.setLongTaskReason("该患者所在科室，有多个出院随访长期任务:" + tempList);
|
// patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
// ServiceTaskdept serviceTaskdept1 = serviceTaskdepts.get(0);
|
// serviceTaskdepts = new ArrayList<>();
|
// serviceTaskdepts.add(serviceTaskdept1);
|
// }
|
//
|
// writeInSubTask(serviceTaskdepts.get(0).getTaskId(), true, patMedInhosp1, patArchive);
|
// }
|
// if (serviceChecks != null && serviceChecks.get(0).getCheckVisitFlag() == 2 || serviceChecks != null && serviceChecks.get(0).getCheckVisitFlag() == 3) {
|
// //丽水需要根据离院疾病对该病人生成一次随访
|
// String[] split = patMedInhosp1.getIcd10code().split(",");
|
// ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
|
// serviceTaskdiag.setLongtask(1L);
|
// serviceTaskdiag.setIcd10code(split[0]);
|
// serviceTaskdiag.setServiceType("2");
|
// List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagList(serviceTaskdiag);
|
// PatMedInhosp patMedInhosp2 = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
|
// //如果疾病编码为空（暂定，将出入院表的check_flag设置为3 ，long_task_reason 记录原因）
|
// if (CollectionUtils.isEmpty(serviceTaskdiags) || serviceTaskdiags.size() == 0) {
|
// patMedInhosp1.setDeptcheckFlag("3");
|
// patMedInhosp1.setLongTaskReason(patMedInhosp2.getLongTaskReason() + "该患者的第一疾病编码，未配置长期任务;");
|
// patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
// continue;
|
// } else if (serviceTaskdiags.size() > 1) {
|
// //如果查询出多个任务，那就取第一个，并在患者备注一下
|
// List<Long> tempList = serviceTaskdiags.stream().map(ServiceTaskdiag::getTaskId).collect(Collectors.toList());
|
// patMedInhosp1.setLongTaskReason(patMedInhosp2.getLongTaskReason() + "该患者的第一疾病编码，有多个出院随访长期任务:" + tempList);
|
// patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
// ServiceTaskdiag serviceTaskdiag1 = serviceTaskdiags.get(0);
|
// serviceTaskdiags = new ArrayList<>();
|
// serviceTaskdiags.add(serviceTaskdiag1);
|
// }
|
// writeInSubTask(serviceTaskdiags.get(0).getTaskId(), false, patMedInhosp1, patArchive);
|
// }
|
//
|
// } catch (Exception e) {
|
// e.printStackTrace();
|
// log.error("人员处理出异常了：{}", e.getMessage());
|
// }
|
// }
|
//
|
// //获取未处理在院的数据(如果刚刚出院的患者数据的出院时间,在下面查询出的入院时间之前,那之前的出院患者的数据,也得停掉,因为又入院了)
|
// patMedInhosp.setDeptcheckFlag("0");
|
// patMedInhosp.setInhospstate("0");
|
// List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
|
// for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
|
// String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
|
// patMedInhosp1.setTagname(tagname);
|
// }
|
// if (CollectionUtils.isNotEmpty(patMedInhospList) && patMedInhospList.size() > 0) {
|
// dealInHospInfo(patMedInhospList);
|
// }
|
// return 1;
|
// }
|
|
/**
|
* 获取出院，住院，门诊服务人次
|
*
|
* @param patMedReq
|
* @return
|
*/
|
@Override
|
public List<PatMedRes> getDeptRanking(PatMedReq patMedReq) {
|
|
return serviceSubtaskMapper.getDeptRanking(patMedReq);
|
}
|
|
@Override
|
public List<PatMedInhosp> getDocAndPat(PatMedInhosp patMedInhosp) {
|
List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
|
for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
|
String tagname = patMedInhospMapper.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();
|
}
|
|
//将患者放到subtask中
|
private void writeInSubTask(Long taskid, Boolean check, PatMedInhosp patMedInhosp1, PatArchive patArchive, Integer type) {
|
String longTaskReason = patMedInhosp1.getLongTaskReason();
|
if (StringUtils.isEmpty(longTaskReason)) longTaskReason = "";
|
ServiceTask st = new ServiceTask();
|
st.setTaskid(taskid);
|
st.setSendState(2L);
|
List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);
|
if (CollectionUtils.isEmpty(serviceTasks) && type == 1) {
|
log.info("该患者出院随访长期任务不存在,任务ID为：{}", taskid);
|
patMedInhosp1.setDeptcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者离院科室长期任务不存在,任务ID为:" + taskid);
|
patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
return;
|
} else if (CollectionUtils.isEmpty(serviceTasks) && type == 2) {
|
patMedInhosp1.setWardcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者离院病区长期任务不存在,任务ID为:" + taskid);
|
patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
return;
|
} else if (CollectionUtils.isEmpty(serviceTasks) && type == 3) {
|
patMedInhosp1.setDiagcheckFlag("2");
|
patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者疾病长期任务不存在,任务ID为:" + taskid);
|
patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
return;
|
}
|
ServiceTask serviceTask = serviceTasks.get(0);
|
//封装serviceSubtask
|
ServiceSubtask serviceSubtask = boxedServiceSubtask(serviceTask, patMedInhosp1, patArchive);
|
if (type != 2) {
|
//科室和疾病 都用 科室填充
|
serviceSubtask.setVisitDeptCode(patMedInhosp1.getLeaveldeptcode());
|
serviceSubtask.setVisitDeptName(patMedInhosp1.getLeaveldeptname());
|
} else if (type == 2) {
|
serviceSubtask.setVisitDeptCode(patMedInhosp1.getLeavehospitaldistrictcode());
|
serviceSubtask.setVisitDeptName(patMedInhosp1.getLeavehospitaldistrictname());
|
}
|
|
|
Integer i = 0;
|
//先判断一下，是否需要校验
|
if (check) {
|
//在新增之前，先通过患者ID，sendstate=2查询一下，在所有长期任务中，是不是还有该患者待执行的任务，有的话,比较之前的endtime是否小于当前的endtaime,如果之前的小于现在的，则直接将之前的停掉（原因再入院）
|
ServiceSubtaskVO subtask = new ServiceSubtaskVO();
|
subtask.setPatid(patArchive.getId());
|
subtask.setSendstate(2L);
|
subtask.setTaskid(taskid);
|
List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
|
log.info("该患者待执行的任务:{}", selectServiceSubtaskList);
|
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) {
|
if (serviceSubtask1.getEndtime().before(serviceSubtask.getEndtime()) && serviceSubtask1.getServiceType().equals("2")) {
|
//如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
|
serviceSubtask1.setSendstate(4L);
|
serviceSubtask1.setRemark("患者再入院");
|
serviceSubtask1.setResult("error");
|
// serviceSubtask1.setFinishtime(new Date());
|
serviceSubtask1.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtask1.setUpdateTime(new Date());
|
Boolean aBoolean = serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
|
if (aBoolean) i = 1;
|
} else {
|
//相反,则将当有的数据停掉
|
serviceSubtask.setResult("error");
|
// serviceSubtask.setFinishtime(new Date());
|
serviceSubtask.setSendstate(4L);
|
serviceSubtask.setRemark("当前患者出院时间后有待执行的出院随访长期任务");
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
}
|
} else if (type == 3) {
|
//type=3 表示疾病
|
//将之前的停掉
|
serviceSubtask1.setSendstate(4L);
|
serviceSubtask1.setRemark("疾病患者再入院");
|
serviceSubtask1.setResult("error");
|
// serviceSubtask1.setFinishtime(new Date());
|
serviceSubtask1.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
|
//重新新增子任务
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
//这里需要全失败
|
addServiceSubtaskPreachform(serviceSubtask, "5");
|
|
}
|
}
|
}
|
} else {
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
addServiceSubtaskPreachform(serviceSubtask, null);
|
}
|
if (i == 1) {
|
//将check_flag改成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");
|
|
patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
|
} else {
|
//生成子任务失败，
|
log.info("生成子任务失败serviceSubtask为：{}", serviceSubtask);
|
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");
|
patMedInhosp2.setRemark("生成子任务失败 " + type);
|
patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
|
}
|
}
|
|
private Integer addServiceSubtaskPreachform(ServiceSubtask serviceSubtask, String sendstate) {
|
//将preachform的json对象，放到list集合中
|
String preachform = serviceSubtask.getPreachform();
|
ObjectMapper objectMapper = new ObjectMapper();
|
if (org.apache.commons.lang3.StringUtils.isNotEmpty(preachform)) {
|
List<ServiceSubtaskPreachform> serviceSubtaskPreachformList = null;
|
try {
|
serviceSubtaskPreachformList = objectMapper.readValue(preachform, new TypeReference<List<ServiceSubtaskPreachform>>() {
|
});
|
} catch (JsonProcessingException e) {
|
log.error("preachform转List<ServiceSubtaskPreachform>报错了：{}", e.getMessage());
|
}
|
for (ServiceSubtaskPreachform serviceSubtaskPreachform : serviceSubtaskPreachformList) {
|
serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
|
serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
|
//这个sendstate需要在数据库设置一个默认值为“1”
|
serviceSubtaskPreachform.setSendstate("1");
|
if (StringUtils.isNotEmpty(sendstate)) serviceSubtaskPreachform.setSendstate(sendstate);
|
|
serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
|
return serviceSubtaskPreachformMapper.insertServiceSubtaskPreachform(serviceSubtaskPreachform);
|
|
}
|
|
}
|
|
return 0;
|
}
|
|
|
//封装serviceSubtask
|
private ServiceSubtask boxedServiceSubtask(ServiceTask serviceTask, PatMedInhosp patMedInhosp1, PatArchive patArchive) {
|
ServiceSubtask serviceSubtask = DtoConversionUtils.sourceToTarget(serviceTask, ServiceSubtask.class);
|
serviceSubtask.setTaskid(serviceTask.getTaskid());
|
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.setDeptcode(patMedInhosp1.getLeaveldeptcode());
|
serviceSubtask.setDeptname(patMedInhosp1.getLeaveldeptname());
|
serviceSubtask.setLeaveicd10code(patMedInhosp1.getLeaveicd10code());
|
serviceSubtask.setLeavediagname(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.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");
|
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());
|
//设置发送时间
|
if (serviceTask.getSendDay() == null) serviceTask.setSendDay(1L);
|
Date newDate = addDays(patMedInhosp1.getEndtime(), serviceTask.getSendDay().intValue());
|
serviceSubtask.setLongSendTime(newDate);
|
serviceSubtask.setVisitTime(newDate);
|
//如果是通知的话，需要提前几天将通过短信发出去（具体几天，这个可以配置在sys_conf表中）
|
if ("3".equals(serviceTask.getType())) {
|
serviceSubtask.setVisitTime(minusDay(newDate, 2));
|
}
|
|
|
//患者发送时间
|
if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) {
|
String remark = patArchive.getNotrequiredreason();
|
serviceSubtask.setRemark(remark);
|
serviceSubtask.setResult("error");
|
//不执行
|
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 {
|
//获取当前入院患者的待执行的出院子任务随访信息
|
ServiceSubtaskVO subtask = new ServiceSubtaskVO();
|
subtask.setPatid(patMedInhosp1.getPatid());
|
subtask.setSendstate(2L);
|
List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
|
// log.error("入院的患者待执行的任务:{}", selectServiceSubtaskList);
|
if (CollectionUtils.isNotEmpty(selectServiceSubtaskList) && selectServiceSubtaskList.size() > 0) {
|
for (ServiceSubtask serviceSubtask1 : selectServiceSubtaskList) {
|
if (Objects.isNull(serviceSubtask1.getLongSendTime())) {
|
//不是长期任务，不处理
|
continue;
|
}
|
if (serviceSubtask1.getEndtime().before(patMedInhosp1.getStarttime())) {
|
//如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
|
// log.error("患者再入院的serviceSubtask1为:{}", serviceSubtask1);
|
serviceSubtask1.setSendstate(4L);
|
serviceSubtask1.setRemark("患者再入院");
|
serviceSubtask1.setResult("error");
|
// serviceSubtask1.setFinishtime(new Date());
|
serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
|
}
|
}
|
}
|
//将患入的入院数据设置为已处理
|
patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
|
} catch (Exception e) {
|
log.error("入院数据信息出异常了：{},{}", patMedInhosp1, e.getMessage());
|
}
|
}
|
}
|
|
}
|
