package com.smartor.service.impl;
|
|
import java.time.LocalDate;
|
import java.time.Period;
|
import java.time.ZoneId;
|
import java.time.temporal.ChronoUnit;
|
import java.util.*;
|
|
import com.ruoyi.common.core.domain.entity.SysDept;
|
import com.ruoyi.common.core.domain.entity.SysUserDept;
|
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 lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.ObjectUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import com.smartor.service.IPatMedOuthospService;
|
import org.springframework.util.CollectionUtils;
|
|
/**
|
* 患者门诊记录Service业务层处理
|
*
|
* @author smartor
|
* @date 2023-03-04
|
*/
|
@Slf4j
|
@Service
|
public class PatMedOuthospServiceImpl implements IPatMedOuthospService {
|
@Autowired
|
private PatMedOuthospMapper patMedOuthospMapper;
|
|
@Autowired
|
private SysUserDeptMapper sysUserDeptMapper;
|
|
@Autowired
|
private ServiceSubtaskMapper serviceSubtaskMapper;
|
|
@Autowired
|
private ServiceTaskMapper serviceTaskMapper;
|
|
@Autowired
|
private ServiceTaskdiagMapper serviceTaskdiagMapper;
|
|
@Autowired
|
private PatArchiveMapper patArchiveMapper;
|
|
|
/**
|
* 查询患者门诊记录
|
*
|
* @param id 患者门诊记录主键
|
* @return 患者门诊记录
|
*/
|
@Override
|
public PatMedOuthosp selectPatMedOuthospById(Long id) {
|
return patMedOuthospMapper.selectPatMedOuthospById(id);
|
}
|
|
/**
|
* 查询患者门诊记录列表
|
*
|
* @param patMedOuthosp 患者门诊记录
|
* @return 患者门诊记录
|
*/
|
@Override
|
public List<PatMedOuthosp> selectPatMedOuthospList(PatMedOuthosp patMedOuthosp) {
|
List<PatMedOuthosp> patMedOuthosps = patMedOuthospMapper.selectPatMedOuthospList(patMedOuthosp);
|
for (PatMedOuthosp patMedOuthosp1 : patMedOuthosps) {
|
PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedOuthosp1.getPatid());
|
if (patArchive.getBirthdate() != null) {
|
Map<String, String> map = calculateAge(patArchive.getBirthdate().toInstant().atZone(ZoneId.systemDefault()).toLocalDate(), LocalDate.now());
|
patArchive.setAge(ObjectUtils.isNotEmpty(map.get("age")) ? Long.valueOf(map.get("age")) : null);
|
patArchive.setAgeUnit(map.get("ageUnit"));
|
patArchive.setAge2(ObjectUtils.isNotEmpty(map.get("age2")) ? Long.valueOf(map.get("age2")) : null);
|
patArchive.setAgeUnit2(map.get("ageUnit2"));
|
patMedOuthosp1.setAge(patArchive.getAge() + patArchive.getAgeUnit() + patArchive.getAge2() + patArchive.getAgeUnit2());
|
patMedOuthosp1.setTelcode(patArchive.getTelcode());
|
patMedOuthosp1.setIdcardno(patArchive.getIdcardno());
|
}
|
}
|
return patMedOuthosps;
|
}
|
|
public Map<String, String> calculateAge(LocalDate birthdate, LocalDate today) {
|
if (birthdate == null || today.isBefore(birthdate)) {
|
return null;
|
}
|
Map<String, String> ageMap = new HashMap<>();
|
|
Period period = Period.between(birthdate, today);
|
long totalDays = ChronoUnit.DAYS.between(birthdate, today);
|
long totalMonths = ChronoUnit.MONTHS.between(birthdate, today);
|
|
int years = period.getYears();
|
int months = period.getMonths();
|
int days = period.getDays();
|
|
String ageUnit;
|
Integer age;
|
String ageUnit2 = null;
|
Integer age2 = null;
|
|
if (totalDays < 30) {
|
// 小于 1 个月，按天计算
|
ageUnit = "天";
|
age = (int) totalDays;
|
ageMap.put("age", age != null ? age.toString() : null);
|
ageMap.put("ageUnit", ageUnit);
|
ageMap.put("age2", null);
|
ageMap.put("ageUnit2", null);
|
} else if (totalMonths < 12) {
|
// 小于 一年，按月 + 天计算
|
ageUnit = "月";
|
age = (int) totalMonths;
|
ageUnit2 = "天";
|
age2 = days;
|
ageMap.put("age", age != null ? age.toString() : null);
|
ageMap.put("ageUnit", ageUnit);
|
ageMap.put("age2", age2 != null ? age2.toString() : null);
|
ageMap.put("ageUnit2", ageUnit2);
|
} else {
|
// 大于等于 一年，按年 + 月计算
|
ageUnit = "岁";
|
age = years;
|
ageUnit2 = "月";
|
age2 = months;
|
ageMap.put("age", age != null ? age.toString() : null);
|
ageMap.put("ageUnit", ageUnit);
|
ageMap.put("age2", age2 != null ? age2.toString() : null);
|
ageMap.put("ageUnit2", ageUnit2);
|
}
|
|
return ageMap;
|
}
|
|
/**
|
* 新增患者门诊记录
|
*
|
* @param patMedOuthosp 患者门诊记录
|
* @return 结果
|
*/
|
@Override
|
public int insertPatMedOuthosp(PatMedOuthosp patMedOuthosp) {
|
patMedOuthosp.setCreateTime(DateUtils.getNowDate());
|
patMedOuthosp.setUpdateTime(DateUtils.getNowDate());
|
return patMedOuthospMapper.insertPatMedOuthosp(patMedOuthosp);
|
}
|
|
/**
|
* 修改患者门诊记录
|
*
|
* @param patMedOuthosp 患者门诊记录
|
* @return 结果
|
*/
|
@Override
|
public int updatePatMedOuthosp(PatMedOuthosp patMedOuthosp) {
|
patMedOuthosp.setUpdateTime(DateUtils.getNowDate());
|
return patMedOuthospMapper.updatePatMedOuthosp(patMedOuthosp);
|
}
|
|
/**
|
* 批量删除患者门诊记录
|
*
|
* @param ids 需要删除的患者门诊记录主键
|
* @return 结果
|
*/
|
@Override
|
public int deletePatMedOuthospByIds(Long[] ids) {
|
return patMedOuthospMapper.deletePatMedOuthospByIds(ids);
|
}
|
|
/**
|
* 删除患者门诊记录信息
|
*
|
* @param id 患者门诊记录主键
|
* @return 结果
|
*/
|
@Override
|
public int deletePatMedOuthospById(Long id) {
|
return patMedOuthospMapper.deletePatMedOuthospById(id);
|
}
|
|
@Override
|
public PatMedRes selectPatMedOuthospCount(PatMedReq patMedReq) {
|
// // 获取当前登陆人的部门权限
|
// if (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);
|
// }
|
return patMedOuthospMapper.selectPatMedOuthospCount(patMedReq);
|
}
|
|
@Override
|
public PatMedOuthosp getDeptCodeByPatId(PatMedOuthosp patMedOuthosp) {
|
List<PatMedOuthosp> patMedOuthosps = selectPatMedOuthospList(patMedOuthosp);
|
if (!CollectionUtils.isEmpty(patMedOuthosps)) {
|
Collections.sort(patMedOuthosps, Comparator.comparing(PatMedOuthosp::getAdmitdate).reversed());
|
}
|
return patMedOuthosps.get(0);
|
}
|
|
/**
|
* 门诊病人信息处理
|
*
|
* @return
|
*/
|
@Override
|
public Integer dealOutpatientInfo() {
|
PatMedOuthosp patMedOuthosp = new PatMedOuthosp();
|
patMedOuthosp.setDiagcheckFlag("0");
|
List<PatMedOuthosp> patMedOuthosps = selectPatMedOuthospList(patMedOuthosp);
|
for (PatMedOuthosp patMedOuthosp1 : patMedOuthosps) {
|
PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedOuthosp1.getPatid());
|
|
//该患者有可能提前来复诊了，那他后面的本科室的通知就可以不用再发短信了
|
ServiceSubtaskVO serviceSubtaskVO = new ServiceSubtaskVO();
|
if (StringUtils.isNotEmpty(patMedOuthosp1.getDeptcode())) {
|
serviceSubtaskVO.setDeptcode(patMedOuthosp1.getDeptcode());
|
serviceSubtaskVO.setSfzh(patArchive.getIdcardno());
|
serviceSubtaskVO.setType("3");
|
serviceSubtaskVO.setSendstate(2L);
|
serviceSubtaskVO.setPreachform("4");
|
List<ServiceSubtask> serviceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtaskVO);
|
if (!CollectionUtils.isEmpty(serviceSubtaskList)) {
|
for (ServiceSubtask serviceSubtask : serviceSubtaskList) {
|
serviceSubtask.setSendstate(6L);
|
serviceSubtask.setRemark("已回来复诊，无需再进行短信通知");
|
serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
|
}
|
}
|
}
|
|
// 根据患者的疾病，获取该疾病的长期任务
|
ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
|
serviceTaskdiag.setLongtask(1L);
|
serviceTaskdiag.setIcd10code(patMedOuthosp1.getIcd10code());
|
List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagList(serviceTaskdiag);
|
//如果部门模板为空（将deptIsNull设置为true）
|
if (org.apache.commons.collections4.CollectionUtils.isEmpty(serviceTaskdiags) || serviceTaskdiags.size() == 0) {
|
patMedOuthosp1.setDiagcheckFlag("2");
|
patMedOuthosp1.setRemark("通过icd10,没有找到随访任务ID");
|
patMedOuthospMapper.updatePatMedOuthosp(patMedOuthosp1);
|
} else {
|
for (ServiceTaskdiag serviceTaskdept1 : serviceTaskdiags) {
|
writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedOuthosp1, patArchive);
|
}
|
}
|
|
}
|
return 1;
|
}
|
|
private void writeInSubTask(Long taskid, Boolean check, PatMedOuthosp patMedOuthosp, PatArchive patArchive) {
|
|
ServiceTask st = new ServiceTask();
|
st.setTaskid(taskid);
|
st.setSendState(2L);
|
List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);
|
if (org.apache.commons.collections4.CollectionUtils.isEmpty(serviceTasks)) {
|
log.error("该患者疾病随访长期任务不存在,任务ID为：{}", taskid);
|
patMedOuthosp.setDiagcheckFlag("2");
|
patMedOuthosp.setRemark("该患者疾病随访长期任务不存在,任务ID为:" + taskid);
|
patMedOuthospMapper.updatePatMedOuthosp(patMedOuthosp);
|
return;
|
}
|
ServiceTask serviceTask = serviceTasks.get(0);
|
//封装serviceSubtask
|
ServiceSubtask serviceSubtask = boxedServiceSubtask(serviceTask, patMedOuthosp, patArchive);
|
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.error("该患者待执行的任务:{}", selectServiceSubtaskList);
|
if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(selectServiceSubtaskList) && selectServiceSubtaskList.size() > 0) {
|
for (ServiceSubtask serviceSubtask1 : selectServiceSubtaskList) {
|
if (Objects.isNull(serviceSubtask1.getLongSendTime())) {
|
//不是长期任务，不处理
|
continue;
|
}
|
|
//将之前的停掉
|
serviceSubtask1.setSendstate(4L);
|
serviceSubtask1.setRemark("疾病患者再入院");
|
serviceSubtask1.setResult("error");
|
// serviceSubtask1.setFinishtime(new Date());
|
serviceSubtask1.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
|
//重新新增子任务
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
|
}
|
} else {
|
if (StringUtils.isEmpty(serviceSubtask.getPhone())) {
|
serviceSubtask.setRemark("手机号为空");
|
serviceSubtask.setSendstate(4L);
|
serviceSubtask.setResult("error");
|
// serviceSubtask.setFinishtime(new Date());
|
}
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
}
|
} else {
|
if (StringUtils.isEmpty(serviceSubtask.getPhone())) {
|
serviceSubtask.setRemark("手机号为空");
|
serviceSubtask.setSendstate(4L);
|
serviceSubtask.setResult("error");
|
// serviceSubtask.setFinishtime(new Date());
|
|
}
|
serviceSubtask.setCreateBy(serviceTask.getCreateBy());
|
serviceSubtask.setCreateTime(new Date());
|
i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
|
}
|
if (i == 1) {
|
//将check_flag改成1（已处理）
|
PatMedOuthosp patMedOuthosp1 = new PatMedOuthosp();
|
patMedOuthosp1.setId(patMedOuthosp.getId());
|
patMedOuthosp1.setDiagcheckFlag("1");
|
patMedOuthospMapper.updatePatMedOuthosp(patMedOuthosp1);
|
} else {
|
//生成子任务失败，
|
log.error("生成子任务失败serviceSubtask为：{}", serviceSubtask);
|
PatMedOuthosp pmo = new PatMedOuthosp();
|
pmo.setId(patMedOuthosp.getId());
|
pmo.setDiagcheckFlag("2");
|
pmo.setRemark("生成子任务失败");
|
patMedOuthospMapper.updatePatMedOuthosp(pmo);
|
}
|
}
|
|
//封装serviceSubtask
|
private ServiceSubtask boxedServiceSubtask(ServiceTask serviceTask, PatMedOuthosp patMedOuthosp, 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.setDrcode(patMedOuthosp.getDrcode());
|
serviceSubtask.setDrname(patMedOuthosp.getDrname());
|
serviceSubtask.setDeptcode(patMedOuthosp.getDeptcode());
|
serviceSubtask.setDeptname(patMedOuthosp.getDeptname());
|
serviceSubtask.setTemplateid(serviceTask.getTemplateid());
|
serviceSubtask.setTemplatename(serviceTask.getTemplatename());
|
serviceSubtask.setPatid(patArchive.getId());
|
serviceSubtask.setSendname(patArchive.getName());
|
serviceSubtask.setSfzh(patArchive.getIdcardno());
|
serviceSubtask.setLeavediagname(patMedOuthosp.getDiagname());
|
serviceSubtask.setLeaveicd10code(patMedOuthosp.getIcd10code());
|
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.setServiceType(serviceTask.getServiceType());
|
serviceSubtask.setPreachform(serviceTask.getPreachform());
|
serviceSubtask.setHospType("1");
|
serviceSubtask.setCreateTime(new Date());
|
serviceSubtask.setUpdateTime(new Date());
|
serviceSubtask.setUpdateBy(serviceTask.getUpdateBy());
|
serviceSubtask.setUpdateTime(new Date());
|
serviceSubtask.setVisitDeptCode(patMedOuthosp.getDeptcode());
|
serviceSubtask.setVisitDeptName(patMedOuthosp.getDeptname());
|
serviceSubtask.setUpdateTime(new Date());
|
//设置发送时间
|
if (serviceTask.getSendDay() == null) serviceTask.setSendDay(1L);
|
Date newDate = addDays(patMedOuthosp.getAdmitdate(), serviceTask.getSendDay().intValue());
|
if (patMedOuthosp.getFudate() != null) {
|
//如果门诊表有指定随访时间，那就用指定的
|
newDate = patMedOuthosp.getFudate();
|
}
|
serviceSubtask.setLongSendTime(newDate);
|
serviceSubtask.setVisitTime(newDate);
|
//患者发送时间
|
if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) {
|
String remark = patArchive.getNotrequiredreason();
|
serviceSubtask.setRemark(remark);
|
serviceSubtask.setResult("error");
|
// serviceSubtask.setFinishtime(new Date());
|
//不执行
|
serviceSubtask.setSendstate(4L);
|
}
|
return serviceSubtask;
|
}
|
|
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();
|
}
|
}
|
