package com.smartor.service.impl; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.google.gson.Gson; import com.google.gson.reflect.TypeToken; import com.ruoyi.common.core.domain.entity.SysDept; import com.ruoyi.common.core.domain.entity.SysUser; import com.ruoyi.common.core.domain.entity.SysUserDept; import com.ruoyi.common.core.domain.entity.SysUserRole; import com.ruoyi.common.utils.DateUtils; import com.ruoyi.common.utils.StringUtils; import com.ruoyi.common.core.service.dto.InhospPositionRecord; import com.smartor.common.enums.EmergencyLevelEnum; import com.smartor.common.enums.ImportFlagEnum; import com.ruoyi.common.utils.http.HttpUtils; import com.smartor.common.DistinctByProperty; import com.smartor.domain.*; import com.ruoyi.outpatientvisit.domain.PatMedOuthospError; import com.ruoyi.outpatientvisit.domain.PatMedOuthosp; import com.ruoyi.inhospvisit.api.InhospVisitFacade; import com.ruoyi.inhospvisit.domain.PatMedInhosp; import com.smartor.mapper.*; import com.ruoyi.outpatientvisit.mapper.PatMedOuthospErrorMapper; import com.smartor.service.IPatArchiveService; import com.smartor.service.IPatMedInhospService; import com.smartor.service.IPatMedOuthospService; import com.smartor.service.IServiceSLTDHealthcareRecordService; import lombok.extern.slf4j.Slf4j; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.ObjectUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.stereotype.Service; import java.lang.reflect.Type; import java.math.BigDecimal; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; import java.util.concurrent.TimeUnit; import java.util.function.Function; import java.util.stream.Collectors; import com.ruoyi.common.core.domain.entity.PatArchive; import com.ruoyi.task.domain.ServiceSubtask; import com.ruoyi.task.mapper.ServiceSubtaskMapper; import com.ruoyi.task.service.impl.ServiceSubtaskServiceImpl; @Slf4j @Service public class ServiceSLTDHealthcareRecordServiceImpl implements IServiceSLTDHealthcareRecordService { private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss"; /** * 在院患者当前位置查询地址（网关根路径 {@code sltd_pub_path} + 固定后缀）。 *

* 与"入院采集"是同一个接口（{@code queryHealthcareRecordList} 用的也是它）， * 区别只是本方法按 {@code healthcareRecordNo} 单查、只取位置字段、不落库。 */ private static final String INHOSP_POSITION_PATH = "/osj/hbos-thirdparty-integration/standard/common/healthcareRecord/dtcQueryHealthcareRecordList"; /** * 当前位置查询的连接/读超时：一轮要按患者调用几千次， * 不能让一次无响应把采集线程无限期挂住（{@code HttpUtils} 老方法没有超时） */ private static final int INHOSP_POSITION_CONNECT_TIMEOUT_MS = 5000; private static final int INHOSP_POSITION_READ_TIMEOUT_MS = 15000; @Autowired private IPatArchiveService patArchiveService; @Autowired private IPatMedInhospService patMedInhospService; @Autowired private IPatMedOuthospService patMedOuthospService; @Autowired private SysUser2Mapper sysUser2Mapper; @Autowired private SysDept2Mapper sysDeptMapper; @Autowired private SysUserDeptMapper sysUserDeptMapper; @Autowired private SysUserRole2Mapper sysUserRoleMapper; @Autowired private MedicationItemMapper medicationItemMapper; @Autowired private MedicationDoseInfoMapper medicationDoseInfoMapper; @Autowired private RedisTemplate redisTemplate; @Value("${sltd_pub_path}") private String sltdPubPath; @Value("${userPwd}") private String userPwd; @Value("${lwl_app_key}") private String APP_KEY; @Value("${spring.profiles.active}") private String active; @Autowired private ServiceSubtaskServiceImpl serviceSubtaskServiceImpl; @Autowired private ServiceSubtaskMapper serviceSubtaskMapper; @Autowired private InhospVisitFacade inhospVisitFacade; @Autowired private PatMedOuthospErrorMapper patMedOuthospErrorMapper; @Override public List queryHealthcareRecordList(ServiceSLTDInhospReqVO reqVO) { try { Map requestParams = buildRequestParams(reqVO); Map headers = buildRequestHeaders(); log.info("请求参数出院数据地址：{},appKey:{}", sltdPubPath + "/osj/hbos-thirdparty-integration/standard/common/healthcareRecord/dtcQueryHealthcareRecordList", APP_KEY); String result = null; if (reqVO.getSize() == null && reqVO.getCurrent() == null) result = HttpUtils.sendPostByHeader(sltdPubPath + "/osj/hbos-thirdparty-integration/standard/common/healthcareRecord/dtcQueryHealthcareRecordList", new Gson().toJson(requestParams), headers); else result = HttpUtils.sendPostByHeader(sltdPubPath + "/osj/hbos-thirdparty-integration/standard/common/healthcareRecord/dtcPageHealthcareRecordList", new Gson().toJson(requestParams), headers); log.info("queryHealthcareRecordList--result返回的结果值：{}", result == null ? "空值" : "有值"); String cry = determineCry(reqVO); log.info("cry的值为：{}", cry); List serviceSLTDInhospResDTOS = parseResponseData(result, CollectionUtils.isNotEmpty(reqVO.getStatusList()) ? reqVO.getStatusList() : reqVO.getHealthcareRecordTypeList(), cry, reqVO.getCampusId() != null ? reqVO.getCampusId().toString() : null); log.info("serviceSLTDInhospResDTOS是否返回的有值：{}", CollectionUtils.isNotEmpty(serviceSLTDInhospResDTOS) ? "有" : "没有"); return serviceSLTDInhospResDTOS; } catch (Exception e) { log.error("【queryHealthcareRecordList】调用省立同德健康记录查询接口异常，请求参数：{}", reqVO, e); throw new RuntimeException("调用省立同德健康记录查询接口失败:" + e.getMessage()); } } @Override /** * 查询药品信息列表 * @return 返回实际获取到的药品数据条数，如果出错则返回 null */ public Integer queryMedicationItemList(ServiceSLTDInhospReqVO reqVO) { try { Map requestParams = buildRequestParams(reqVO); Map headers = buildRequestHeaders(); log.info("请求参药品信息地址：{},appKey:{}", sltdPubPath + "/hbos-thirdparty-integration/standard/base/mc/service/medication/queryMedicationInfoPage", APP_KEY); String result = HttpUtils.sendPostByHeader(sltdPubPath + "/hbos-thirdparty-integration/standard/base/mc/service/medication/queryMedicationInfoPage", new Gson().toJson(requestParams), headers); List> dataList = getDataList(result, 2); log.info("【queryMedicationItemList】共获取到{}条药品数据", dataList.size()); int successCount = 0; int failCount = 0; for (Map dataItem : dataList) { try { MedicationItem medicationItem = convertToMedication(dataItem); log.info("准备插入药品数据：itemName={}, itemCode={}", medicationItem.getItemName(), medicationItem.getItemCode()); medicationItem.setCreateTime(new Date()); medicationItemMapper.insertMedicationItem(medicationItem); // 如果插入成功且返回了自增 ID，则插入子表 if (medicationItem.getId() != null) { List doseInfoList = medicationItem.getDoseInfoList(); if (CollectionUtils.isNotEmpty(doseInfoList)) { for (MedicationDoseInfo doseInfo : doseInfoList) { try { doseInfo.setMedicationItemId(medicationItem.getId()); medicationDoseInfoMapper.insertMedicationDoseInfo(doseInfo); log.debug("插入剂量信息成功：itemId={}, doseUnit={}", medicationItem.getId(), doseInfo.getDoseUnit()); } catch (Exception e) { log.warn("插入剂量信息失败：itemId={}, doseUnit={}, 错误:{}", medicationItem.getId(), doseInfo.getDoseUnit(), e.getMessage(), e); failCount++; } } } } successCount++; log.info("✓ 药品数据插入成功：{}", medicationItem.getItemName()); } catch (Exception e) { log.warn("【queryMedicationItemList】单条药品数据插入失败：itemName={}, itemCode={}, 错误:{}", dataItem.get("itemName"), dataItem.get("itemCode"), e.getMessage(), e); failCount++; // 继续处理下一条数据，不中断整个循环 } } log.info("【queryMedicationItemList】批量插入完成，总数:{}, 成功:{}, 失败:{}", dataList.size(), successCount, failCount); // 返回实际获取到的药品数据条数，用于分页判断是否还有更多数据 return dataList.size(); } catch (Exception e) { log.error("【queryMedicationItemList】调用省立同德药品信息查询接口异常，请求参数：{}", reqVO, e); throw new RuntimeException(e); } } /** * 采集科室病区信息 * * @param serviceSLTDDeptReqVO * @return 参考 * { * "orgId": 20001001, * "campusIds": 30001002, * "unitIds": null, * "relationType": null, * "searchText": null, * "status": 1 * } */ @Override public Boolean queryDeptWardAreaInfoList(ServiceSLTDDeptReqVO serviceSLTDDeptReqVO) { log.info("【queryDeptWardAreaInfoList】开始调用省立同德科室病区查询接口，请求参数：{}", serviceSLTDDeptReqVO); try { Map params = new HashMap<>(); if (serviceSLTDDeptReqVO.getOrgId() != null) { params.put("orgId", Long.parseLong(serviceSLTDDeptReqVO.getOrgId())); } if (serviceSLTDDeptReqVO.getCampusIds() != null) { params.put("campusIds", serviceSLTDDeptReqVO.getCampusIds()); } params.put("subjectCode", serviceSLTDDeptReqVO.getSubjectCode()); params.put("orgSubjectCode", serviceSLTDDeptReqVO.getOrgSubjectCode()); params.put("deptDimensions", serviceSLTDDeptReqVO.getDeptDimensions()); params.put("serviceScopes", serviceSLTDDeptReqVO.getServiceScopes()); params.put("inpatientArea", serviceSLTDDeptReqVO.getInpatientArea()); params.put("status", serviceSLTDDeptReqVO.getStatus()); Map headers = buildRequestHeaders(); String result = HttpUtils.sendPostByHeader(sltdPubPath + "/osj/hbos-thirdparty-integration/standard/common/dept/queryDeptList", new Gson().toJson(params), headers); log.info("【queryDeptWardAreaInfoList】接口响应结果：{}", StringUtils.isEmpty(result) ? "空的" : "不空"); List> dataList = getDataList(result, 1); log.info("-----------dataList接口响应结果：{}", dataList.size()); for (Map dataItem : dataList) { SysDept sysDept = new SysDept(); sysDept.setOrgid("" + getLongValue(dataItem, "orgId")); sysDept.setCampusid("" + getLongValue(dataItem, "campusId")); sysDept.setHisDeptId("" + getLongValue(dataItem, "deptId")); sysDept.setHisParentId(getStringValue(dataItem, "parentDeptId")); //通过his的父科室ID去找到科室ID,填充parentId if (StringUtils.isNotEmpty(getStringValue(dataItem, "parentDeptId"))) { SysDept sd = new SysDept(); sd.setHisDeptId(getStringValue(dataItem, "parentDeptId")); sd.setOrgid(getStringValue(dataItem, "orgId")); List sysDepts = sysDeptMapper.selectDeptList(sd); if (CollectionUtils.isNotEmpty(sysDepts)) { SysDept sysDept1 = sysDepts.get(0); sysDept.setParentId(sysDept1.getDeptId()); sysDept.setParentName(sysDept1.getDeptName()); } } sysDept.setDeptName(getStringValue(dataItem, "deptName")); Integer inpatientArea = getIntegerValue(dataItem, "inpatientArea"); if (inpatientArea != null && inpatientArea == 0) sysDept.setDeptType("1"); else if (inpatientArea != null && inpatientArea == 1) sysDept.setDeptType("2"); sysDept.setLeader(""); Integer status = getIntegerValue(dataItem, "status"); if (status != null & status == 0) sysDept.setStatus("1"); if (status != null & status == 1) sysDept.setStatus("0"); sysDept.setType(""); sysDept.setDeptCode("" + getLongValue(dataItem, "deptId")); sysDept.setCreateBy(null); sysDept.setCreateTime(new Date()); sysDept.setUpdateTime(new Date()); sysDept.setUpdateBy(null); // 按 deptCode + orgid + campusid 查重，避免跨院区科室重复 SysDept sysDept1 = sysDeptMapper.selectDeptByCodeAndCampus(sysDept.getDeptCode(), sysDept.getOrgid(), sysDept.getCampusid()); if (Objects.isNull(sysDept1)) { try { int i = sysDeptMapper.insertDept(sysDept); log.info("ServiceExternalServiceImpl---addDeptInfo是否新增成功：{}", i); } catch (org.springframework.dao.DuplicateKeyException e) { log.warn("【queryDeptWardAreaInfoList】科室已存在(并发插入)，跳过：deptCode={}, orgid={}, campusid={}", sysDept.getDeptCode(), sysDept.getOrgid(), sysDept.getCampusid()); } } else { sysDept.setDeptId(sysDept1.getDeptId()); int i = sysDeptMapper.updateDept(sysDept); log.info("ServiceExternalServiceImpl---addDeptInfo是否修改成功04：{}", i); } } } catch (Exception e) { e.printStackTrace(); } return true; } /** * 采集医院用户信息 * * @param reqVO * @return */ @Override public Boolean queryHospUserInfoList(ServiceSLTDInhospReqVO reqVO) { Map requestParams = buildRequestParams(reqVO); Map headers = buildRequestHeaders(); String result = HttpUtils.sendPostByHeader(sltdPubPath + "/osj/hbos-thirdparty-integration/standard/common/staff/queryStaffList", new Gson().toJson(requestParams), headers); log.info("【queryHealthcareRecordList】接口响应结果是否有值：{}", StringUtils.isEmpty(result) ? "没值" : "有值"); List> dataList = getDataList(result, 1); for (Map dataItem : dataList) { SysUser sysUser = new SysUser(); if (StringUtils.isEmpty(getStringValue(dataItem, "accountNo"))) { continue; } sysUser.setUserName(getStringValue(dataItem, "accountNo")); sysUser.setNickName(getStringValue(dataItem, "name")); List diagnosisObjList = (List) dataItem.get("qualifications"); if (CollectionUtils.isNotEmpty(diagnosisObjList)) { for (Object diagnosis : diagnosisObjList) { if (diagnosis instanceof Map) { Map diagnosisMap = (Map) diagnosis; String professionalTitleName = getStringValue(diagnosisMap, "professionalTitleName"); if (professionalTitleName.contains("医师")) { sysUser.setUserType("医生"); } if (professionalTitleName.contains("护")) { sysUser.setUserType("护士"); } sysUser.setTitle(getStringValue(diagnosisMap, "professionalTitleName")); } } } //如果用户的患者范围为空，则默认为0 if (StringUtils.isEmpty(sysUser.getSearchscope())) sysUser.setSearchscope("0"); sysUser.setPhonenumber(getStringValue(dataItem, "telephone")); sysUser.setUserCode(getStringValue(dataItem, "jobNumber")); //设置性别 String genderName = getStringValue(dataItem, "genderName"); if ("男".equals(genderName)) sysUser.setSex("0"); else if ("女".equals(genderName)) sysUser.setSex("1"); else sysUser.setSex("2"); sysUser.setCreateTime(new Date()); sysUser.setUpdateTime(new Date()); sysUser.setUpdateBy("admin"); sysUser.setCreateBy("admin"); sysUser.setOrgid("" + getLongValue(dataItem, "orgId")); BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder(); sysUser.setPassword(passwordEncoder.encode(userPwd)); SysUser sysUser1 = sysUser2Mapper.selectUserByUserName(sysUser.getUserName()); if (ObjectUtils.isNotEmpty(sysUser1)) { //已存在：由人工维护的字段是不需要更新的，orgid/campusid保留原值不覆盖 sysUser.setSearchscope(null); sysUser.setPassword(null); sysUser.setUserId(sysUser1.getUserId()); sysUser.setOrgid(null); sysUser.setCampusid(null); sysUser2Mapper.updateUser(sysUser); } else { try { sysUser2Mapper.insertUser(sysUser); } catch (org.springframework.dao.DuplicateKeyException e) { //并发插入场景：重新查询获取已存在记录，避免重复 log.warn("【queryHospUserInfoList】用户已存在(并发插入)，跳过：userName={}", sysUser.getUserName()); SysUser existingUser = sysUser2Mapper.selectUserByUserName(sysUser.getUserName()); if (ObjectUtils.isNotEmpty(existingUser)) { sysUser.setUserId(existingUser.getUserId()); } } } // 处理用户与部门的关系 List businessDepts = (List) dataItem.get("businessDepts"); if (CollectionUtils.isNotEmpty(businessDepts)) { List> deptInfoList = new ArrayList<>(); List> hospInfoList = new ArrayList<>(); log.info("------businessDepts是否有值：{}", businessDepts.size()); for (Object businessDept : businessDepts) { if (businessDept instanceof Map) { Map businessDeptMap = (Map) businessDept; log.info("------businessDeptMap是否有值：{}", businessDeptMap); String hisDeptId = getStringValue(businessDeptMap, "deptId"); log.info("------hisDeptId是否有值：{}, reqVO.getOrgId()的值为:{}", hisDeptId, reqVO.getCampusId()); //在这里，hisDeptId就是deptCode，按院区+机构查科室，避免跨院区查错 SysDept sysDept = sysDeptMapper.selectDeptByCodeAndCampus(hisDeptId, reqVO.getOrgId(), reqVO.getCampusId() != null ? reqVO.getCampusId().toString() : null); log.info("------hisDeptId是否有值：{}, reqVO.getCampusId()的值为:{}", hisDeptId, reqVO.getCampusId()); if (Objects.isNull(sysDept)) continue; SysUserDept sysUserDept = new SysUserDept(); sysUserDept.setUserId(sysUser.getUserId()); sysUserDept.setDeptType(sysDept.getDeptType()); sysUserDept.setDeptId(sysDept.getDeptId()); sysUserDept.setDeptCode(sysDept.getDeptCode()); sysUserDept.setDeptName(sysDept.getDeptName()); sysUserDept.setOrgid(sysDept.getOrgid()); sysUserDept.setCreateTime(new Date()); sysUserDept.setDelFlag(0L); //判断一下用户-部门关系是不是已经存在了（无论新用户还是老用户都需要去重） if (ObjectUtils.isNotEmpty(sysUser.getUserId()) && ObjectUtils.isNotEmpty(sysDept)) { SysUserDept sud = new SysUserDept(); sud.setUserId(sysUser.getUserId()); sud.setDeptId(sysDept.getDeptId()); sud.setOrgid(sysDept.getOrgid()); List sysUserDepts = sysUserDeptMapper.selectSysUserDeptList(sud); if (CollectionUtils.isNotEmpty(sysUserDepts)) { sysUserDept.setId(sysUserDepts.get(0).getId()); sysUserDeptMapper.updateSysUserDept(sysUserDept); } else { sysUserDeptMapper.insertSysUserDept(sysUserDept); } } if (StringUtils.isNotEmpty(sysDept.getDeptType()) && sysDept.getDeptType().equals("1")) { hospInfoList.add(Arrays.asList(sysDept.getDeptCode())); } else if (StringUtils.isNotEmpty(sysDept.getDeptType()) && sysDept.getDeptType().equals("2")) { deptInfoList.add(Arrays.asList(sysDept.getDeptCode())); } } } //将部门我病区放到指定字段中 Gson gson = new Gson(); sysUser.setHospInfo(gson.toJson(hospInfoList)); sysUser.setDeptInfo(gson.toJson(deptInfoList)); sysUser2Mapper.updateUser(sysUser); } //设置一个默认角色（医生角色） List userRoleList = new ArrayList(); SysUserRole sur = new SysUserRole(); sur.setUserId(sysUser.getUserId()); sur.setRoleId(4L); sur.setOrgid(sysUser.getOrgid()); //先查询一下，是否存在 SysUserRole sysUserRole = sysUserRoleMapper.selectUserRoleByRoleIdAndUserId(4L, sysUser.getUserId()); if (ObjectUtils.isNotEmpty(sysUserRole)) continue; userRoleList.add(sur); sysUserRoleMapper.batchUserRole(userRoleList); } return true; } @Override public List queryInhospPosition(ServiceSLTDInhospReqVO reqVO) { // 与"入院采集"共用同一套入参构造：orgId + campusIds + statusList + healthcareRecordNo Map requestParams = buildRequestParams(reqVO); Map headers = buildRequestHeaders(); String url = sltdPubPath + INHOSP_POSITION_PATH; String result = HttpUtils.sendPostByHeader(url, new Gson().toJson(requestParams), headers, INHOSP_POSITION_CONNECT_TIMEOUT_MS, INHOSP_POSITION_READ_TIMEOUT_MS); if (StringUtils.isEmpty(result)) { // sendPostByHeader 把异常吞掉后返回空串：这里绝不能当成"该患者已不在院"， // 否则接口整体不可用时会被记成"几千个患者都出院了"，与真相反。 throw new RuntimeException("查询在院患者当前位置接口无响应，healthcareRecordNo=" + reqVO.getHealthcareRecordNo()); } // getDataList 在返回码非 200 时抛 RuntimeException；data 为 []（该患者已不在入院状态）时返回空列表 List> dataList = getDataList(result, 1); List records = new ArrayList<>(dataList.size()); for (Map dataItem : dataList) { records.add(convertToInhospPosition(dataItem)); } return records; } /** * 健康记录 JSON → 契约 DTO 的逐字段搬运（只取"当前位置"要用的字段）。 *

* 一律走 {@code getStringValue} / {@code getLongValue}：接口对空值可能返回 {@code null}、 * {@code ""} 甚至缺字段，直接让 Gson 反序列化到 Long 字段会在空串上抛 NumberFormatException。 */ private InhospPositionRecord convertToInhospPosition(Map dataItem) { InhospPositionRecord record = new InhospPositionRecord(); record.setHealthcareRecordNo(getStringValue(dataItem, "healthcareRecordNo")); record.setPatientName(getStringValue(dataItem, "patientName")); record.setDeptId(getLongValue(dataItem, "deptId")); record.setDeptName(getStringValue(dataItem, "deptName")); record.setAreaId(getLongValue(dataItem, "areaId")); record.setAreaName(getStringValue(dataItem, "areaName")); record.setBedNumber(getStringValue(dataItem, "bedNumber")); record.setHealthcareRecordStatus(getStringValue(dataItem, "healthcareRecordStatus")); return record; } private String determineCry(ServiceSLTDInhospReqVO reqVO) { if (CollectionUtils.isEmpty(reqVO.getStatusList()) && CollectionUtils.isEmpty(reqVO.getHealthcareRecordTypeList())) return null; if (reqVO.getStatusList() != null) { if (reqVO.getStatusList().contains("FH0109.24")) { //入院 return "0"; } else if (reqVO.getStatusList().contains("FH0109.27")) { //出院 return "1"; } else if (reqVO.getStatusList().contains("FH0109.22") || reqVO.getStatusList().contains("FH0109.23") || reqVO.getStatusList().contains("FH0109.53")) { //预入院 return "3"; } } if (reqVO.getHealthcareRecordTypeList() != null) { if (reqVO.getHealthcareRecordTypeList().contains("FH0108.03") || reqVO.getHealthcareRecordTypeList().contains("FH0108.01")) { //门急诊 return "4"; } } return null; } private Map buildRequestParams(ServiceSLTDInhospReqVO reqVO) { Map params = new HashMap<>(); if (reqVO.getOrgId() != null) { params.put("orgId", Long.parseLong(reqVO.getOrgId())); } if (reqVO.getCampusId() != null) { params.put("campusIds", reqVO.getCampusId()); } if (reqVO.getStartHeadTime() != null) { params.put("startHeadTime", reqVO.getStartHeadTime()); } if (reqVO.getStartTailTime() != null) { params.put("startTailTime", reqVO.getStartTailTime()); } if (reqVO.getEncounterTimeStart() != null) { params.put("encounterTimeStart", reqVO.getEncounterTimeStart()); } if (reqVO.getEncounterTimeEnd() != null) { params.put("encounterTimeEnd", reqVO.getEncounterTimeEnd()); } if (reqVO.getPreOutHospitalHeadDate() != null) { params.put("preOutHospitalHeadDate", reqVO.getPreOutHospitalHeadDate()); } if (reqVO.getPreOutHospitalTailDate() != null) { params.put("preOutHospitalTailDate", reqVO.getPreOutHospitalTailDate()); } if (reqVO.getHealthcareRecordTypeList() != null && !reqVO.getHealthcareRecordTypeList().isEmpty()) { params.put("healthcareRecordTypeList", reqVO.getHealthcareRecordTypeList()); } if (reqVO.getStatusList() != null && !reqVO.getStatusList().isEmpty()) { params.put("statusList", reqVO.getStatusList()); } params.put("subjectCode", reqVO.getPatientName()); params.put("healthcareRecordNo", reqVO.getHealthcareRecordNo()); params.put("orgSubjectCode", reqVO.getIdCardNo()); if (reqVO.getDeptIdList() != null && !reqVO.getDeptIdList().isEmpty()) { params.put("deptDimensions", reqVO.getDeptIdList()); } params.put("serviceScopes", null); params.put("inpatientArea", null); // params.put("status", reqVO.getStatusList() != null && !reqVO.getStatusList().isEmpty() ? reqVO.getStatusList().get(0) : null); params.put("status", null); // 分页参数（门急诊分页采集时使用） if (reqVO.getCurrent() != null) { params.put("current", reqVO.getCurrent()); } if (reqVO.getSize() != null) { params.put("size", reqVO.getSize()); } return params; } private Map buildRequestHeaders() { Map headers = new HashMap<>(); headers.put("Content-Type", "application/json"); headers.put("app-key", APP_KEY); return headers; } private List parseResponseData(String result, List types, String cry, String campusId) { try { List> dataList = getDataList(result, cry.equals("4") ? 2 : 1); log.info("【parseResponseData】成功解析dataList:{}条健康记录数据", dataList.size()); List resultList = new ArrayList<>(); for (Map dataItem : dataList) { try { resultList.add(convertToDTO(dataItem)); } catch (Exception e) { // 单条数据转换失败不再让整页失败：写错误表交给人工处理，其余记录照常入库 saveOuthospError(dataItem, "CONVERT", e.getMessage(), new Gson().toJson(dataItem), e); } } log.info("【parseResponseData】成功解析resultList:{}条健康记录数据", resultList.size()); processResultList(resultList, types, cry, campusId); return resultList; } catch (Exception e) { log.error("【parseResponseData】解析响应数据异常，响应内容：{}", result, e); throw new RuntimeException("解析响应数据失败", e); } } /** * 解析接口返回数据 * * @param result 接口返回数据 * @param flag 1代表，数组在data里，2代表数组在data/records里 * @return 解析后的数据列表 */ public List> getDataList(String result, Integer flag) { Gson gson = new Gson(); Type mapType = new TypeToken>() { }.getType(); Map responseMap = gson.fromJson(result, mapType); log.info("【parseResponseData】接口返回数据的responseMap：{}", Objects.isNull(responseMap) ? "空的" : "有值"); Number codeNum = (Number) responseMap.get("code"); String code = BigDecimal.valueOf(codeNum.longValue()).toPlainString(); if (StringUtils.isEmpty(code) || !code.equals("200")) { log.error("【parseResponseData】接口返回失败，响应码：{}，响应内容：{}", code, result); throw new RuntimeException("接口调用失败，响应码：" + code); } Object dataObj = responseMap.get("data"); if (flag == 1) { dataObj = responseMap.get("data"); } else if (flag == 2) { //门急诊的分页数据是在records中 dataObj = ((Map) responseMap.get("data")).get("records"); log.info("【parseResponseData】接口返回数据的dataObj：{}", Objects.isNull(dataObj) ? "空的" : "有值"); } if (dataObj == null) { log.info("【parseResponseData】接口返回数据为空"); return new ArrayList<>(); } // 兼容data为数组或对象两种情况：接口正常时data为[{...}]数组， // 异常或空数据时可能返回{}对象，直接按List解析会抛JsonSyntaxException List> dataList; if (dataObj instanceof List) { String dataJson = gson.toJson(dataObj); Type listType = new TypeToken>>() { }.getType(); dataList = gson.fromJson(dataJson, listType); } else { log.info("【parseResponseData】接口返回data不是数组，而是对象类型，data内容：{}", gson.toJson(dataObj)); return new ArrayList<>(); } // 使用 Set 去重，确保没有重复的数据 Set> uniqueDataSet = new HashSet<>(dataList); dataList = new ArrayList<>(uniqueDataSet); return dataList; } private void processResultList(List resultList, List types, String cry, String campusId) { // 门诊(FH0108.01)和急诊(FH0108.03)在业务上是同一类数据，共用同一个 resultList。 // 若 types 同时包含两者，outHospitalDate 会被调用两次导致重复入库。 // 因此只要 types 中含有任意一个门急诊类型，就只处理一次。 boolean outpProcessed = false; for (String type : types) { switch (type) { case "FH0108.01": case "FH0108.03": if (!outpProcessed) { log.info("【parseResponseData】解析门急诊数据，types={}", types); outHospitalDate(resultList); outpProcessed = true; } else { log.info("【parseResponseData】门急诊数据已处理，跳过 type={}", type); } break; case "FH0109.24": log.info("【parseResponseData】解析住院数据"); inHospitalDate(resultList, cry); break; case "FH0109.22": log.info("【parseResponseData】解析预住院数据"); inHospitalDate(resultList, cry); break; case "FH0109.23": log.info("【parseResponseData】解析预住院（待安床）数据"); inHospitalDate(resultList, cry); break; case "FH0109.27": log.info("【parseResponseData】解析出院数据"); inHospitalDate(resultList, cry); break; case "FH0109.53": log.info("【parseResponseData】解析预住院（其他）数据"); inHospitalDate(resultList, cry); break; default: log.warn("【parseResponseData】未知的数据类型：{}", type); break; } } } private Boolean outHospitalDate(List resultList) { // 门急诊在 HIS 侧只能按天查，采集任务每半小时都会把当天上万个诊疗记录重新拉一遍， // 其中绝大多数上一轮已经入库。这里先整页批量查重，把已入库的直接跳过， // 只对新增记录做"档案处理 + 入库"，否则每条重复数据都要走一遍 // Redis加锁 + 档案查重 + 档案更新 + countBySerialnum + insert，一万条就是几万次 SQL，半小时跑不完。 Set pageSerialnums = new HashSet<>(); List uniqueList = new ArrayList<>(); List noSerialnumList = new ArrayList<>(); Map> serialnumsByDate = new LinkedHashMap<>(); for (ServiceSLTDInhospResDTO dto : resultList) { if (Objects.isNull(dto)) { continue; } String serialnum = dto.getHealthcareRecordNo(); if (StringUtils.isEmpty(serialnum)) { // 没有诊疗记录号就没法查重，保持原有行为照常处理（入库环节还会再兜一次） log.warn("【outHospitalDate】诊疗记录号为空，无法查重，按新增处理：patientName={}", dto.getPatientName()); noSerialnumList.add(dto); continue; } if (!pageSerialnums.add(serialnum)) { // 同一页内重复的记录，只处理一条 continue; } uniqueList.add(dto); // 按就诊日期分组（跨零点时最多两个日期），保证查重的分表和入库时分表路由一致 String admitDateStr = formatAdmitDate(dto.getLastEncounterTime()); serialnumsByDate.computeIfAbsent(admitDateStr == null ? "" : admitDateStr, k -> new ArrayList<>()).add(serialnum); } // 一次 SQL 查出这一页里已经入库的 serialnum（取代逐条 countBySerialnum） Set existingSerialnums = new HashSet<>(); for (Map.Entry> entry : serialnumsByDate.entrySet()) { try { existingSerialnums.addAll(patMedOuthospService.selectExistingSerialnums(entry.getKey(), entry.getValue())); } catch (Exception e) { // 批量查重失败不影响正确性：下面入库时每条还会再查一次重，只是慢一些 log.error("【outHospitalDate】批量查重失败，退化为逐条查重，就诊日期：{}", entry.getKey(), e); } } List batchList = new ArrayList<>(); int existSkipCount = 0; for (ServiceSLTDInhospResDTO dto : uniqueList) { if (existingSerialnums.contains(dto.getHealthcareRecordNo())) { existSkipCount++; continue; } PatMedOuthosp patMedOuthosp = buildNewOuthosp(dto); if (patMedOuthosp != null) { batchList.add(patMedOuthosp); } } for (ServiceSLTDInhospResDTO dto : noSerialnumList) { PatMedOuthosp patMedOuthosp = buildNewOuthosp(dto); if (patMedOuthosp != null) { batchList.add(patMedOuthosp); } } log.info("【outHospitalDate】本页{}条，去重后{}条，已入库跳过{}条，待入库{}条", resultList.size(), uniqueList.size(), existSkipCount, batchList.size()); // 批量插入，自动忽略重复 if (CollectionUtils.isNotEmpty(batchList)) { //这里用自动忽略重复会有问题，如果表重新建，serialnum索引会丢失。就无法去重，所以还是需要内存里去重 batchList = DistinctByProperty.distinctByProperty(batchList, PatMedOuthosp::getSerialnum); int insertCount = 0; int skipCount = 0; List failSerialnums = new ArrayList<>(); for (PatMedOuthosp patMedOuthosp : batchList) { try { int inserted = patMedOuthospService.insertPatMedOuthosp(patMedOuthosp); if (inserted > 0) { insertCount += inserted; } else { // 返回0表示已存在（重复采集）或就诊时间为空，属于正常跳过，不算失败 skipCount++; } } catch (Exception e) { // 单条入库失败不再中断采集：落错误表交给人工处理，采集断点照常推进 failSerialnums.add(patMedOuthosp.getSerialnum()); saveOuthospError(null, patMedOuthosp, "INSERT", e.getMessage(), new Gson().toJson(patMedOuthosp), e); } } log.info("批量插入门急诊记录，总数：{}, 实际插入：{}, 跳过（已存在/无就诊时间）：{}, 落错误表：{}", batchList.size(), insertCount, skipCount, failSerialnums.size()); if (!failSerialnums.isEmpty()) { // 失败明细已逐条写进 pat_med_outhosp_error，这里只提示，不再抛异常阻断采集 log.error("门急诊记录入库失败 {} 条，已写入 pat_med_outhosp_error 等人工处理，serialnum：{}", failSerialnums.size(), failSerialnums); } } return true; } /** * 处理单条新增记录的患者档案并构建门急诊记录； * 失败时写错误表交给人工处理并返回 null，不影响同一页里其他记录 */ private PatMedOuthosp buildNewOuthosp(ServiceSLTDInhospResDTO dto) { try { PatArchive patArchive = processPatientArchive(dto); return buildPatMedOuthosp(dto, patArchive); } catch (Exception e) { saveOuthospError(dto, null, "ARCHIVE", e.getMessage(), new Gson().toJson(dto), e); return null; } } /** 采集失败的原始记录来自接口返回的 Map（数据转换失败时还没有 DTO） */ private void saveOuthospError(Map dataItem, String errorType, String errorMsg, String rawData, Throwable cause) { PatMedOuthospError error = new PatMedOuthospError(); error.setSerialnum(getStringValue(dataItem, "healthcareRecordNo")); error.setOuthospno(getStringValue(dataItem, "healthcareRecordNo")); error.setPatname(getStringValue(dataItem, "patientName")); error.setPatno(getStringValue(dataItem, "medicalRecordNo")); error.setCampusid(getStringValue(dataItem, "campusId")); error.setOrgid(getStringValue(dataItem, "orgId")); doSaveOuthospError(error, errorType, errorMsg, rawData, cause); } /** 采集失败的原始记录来自 DTO / 待入库的 PatMedOuthosp */ private void saveOuthospError(ServiceSLTDInhospResDTO dto, PatMedOuthosp patMedOuthosp, String errorType, String errorMsg, String rawData, Throwable cause) { PatMedOuthospError error = new PatMedOuthospError(); if (dto != null) { error.setSerialnum(dto.getHealthcareRecordNo()); error.setOuthospno(dto.getHealthcareRecordNo()); error.setPatname(dto.getPatientName()); error.setPatno(dto.getMedicalRecordNo()); error.setCampusid(dto.getCampusId()); error.setOrgid(dto.getOrgId()); error.setAdmitdate(parseDate(dto.getLastEncounterTime())); } if (patMedOuthosp != null) { if (StringUtils.isEmpty(error.getSerialnum())) { error.setSerialnum(patMedOuthosp.getSerialnum()); } error.setOuthospno(patMedOuthosp.getOuthospno()); error.setPatname(patMedOuthosp.getPatname()); error.setPatno(patMedOuthosp.getPatno()); error.setCampusid(patMedOuthosp.getCampusid()); error.setOrgid(patMedOuthosp.getOrgid()); error.setAdmitdate(patMedOuthosp.getAdmitdate()); } doSaveOuthospError(error, errorType, errorMsg, rawData, cause); } /** * 写门急诊采集失败记录表，交给人工处理。 * 这里兜住一切异常：连错误表都写不进去时只打日志（带原始数据），绝不因为写错误表失败而中断采集 */ private void doSaveOuthospError(PatMedOuthospError error, String errorType, String errorMsg, String rawData, Throwable cause) { error.setErrorType(errorType); error.setErrorMsg(truncate(errorMsg == null || errorMsg.isEmpty() ? String.valueOf(cause) : errorMsg, 1000)); error.setRawData(rawData); error.setFailCount(1); error.setHandleStatus("0"); error.setGatherDate(new SimpleDateFormat("yyyy-MM-dd").format(new Date())); error.setCreateTime(DateUtils.getNowDate()); try { patMedOuthospErrorMapper.insertPatMedOuthospError(error); log.error("【门急诊采集】{} 失败，已写入 pat_med_outhosp_error 等人工处理，serialnum={}，患者={}，原因={}", errorType, error.getSerialnum(), error.getPatname(), error.getErrorMsg(), cause); } catch (Exception ex) { log.error("【门急诊采集】{} 失败，且写入错误表也失败，serialnum={}，原始数据：{}", errorType, error.getSerialnum(), rawData, ex); } } /** 截断超长文本，避免超出错误表字段长度导致落表失败 */ private String truncate(String text, int maxLength) { if (text == null) { return null; } return text.length() <= maxLength ? text : text.substring(0, maxLength); } private PatMedOuthosp buildPatMedOuthosp(ServiceSLTDInhospResDTO dto, PatArchive patArchive) { PatMedOuthosp patMedOuthosp = new PatMedOuthosp(); patMedOuthosp.setOuthospno(dto.getHealthcareRecordNo()); patMedOuthosp.setSerialnum(dto.getHealthcareRecordNo()); patMedOuthosp.setPatid(patArchive.getId()); patMedOuthosp.setPatname(patArchive.getName()); patMedOuthosp.setPatno(patArchive.getPatientno()); patMedOuthosp.setDeptcode("" + dto.getDeptId()); patMedOuthosp.setDeptname(dto.getDeptName()); patMedOuthosp.setDiagname(dto.getDiagnosisName()); patMedOuthosp.setIcd10code(dto.getDiagnosisCode()); patMedOuthosp.setDrcode("" + dto.getDoctorId()); patMedOuthosp.setDrname(dto.getDoctorName()); patMedOuthosp.setAdmitdate(parseDate(dto.getLastEncounterTime())); patMedOuthosp.setSchemestatus(1L); patMedOuthosp.setMainsuit(dto.getDiagnosisName()); patMedOuthosp.setHpi(null); patMedOuthosp.setCreateTime(new Date()); patMedOuthosp.setOrgid(dto.getOrgId()); patMedOuthosp.setCampusid(dto.getCampusId()); patMedOuthosp.setFuflag("1"); if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) patMedOuthosp.setFuflag("0"); return patMedOuthosp; } private Date parseDate(String dateStr) { if (StringUtils.isEmpty(dateStr)) { return null; } try { return new SimpleDateFormat(DATE_FORMAT).parse(dateStr); } catch (ParseException e) { log.warn("【parseDate】解析日期失败：{}", dateStr, e); return null; } } /** * 取就诊日期的 yyyy-MM-dd 部分，与 buildPatMedOuthosp 里的 admitdate 保持完全一致的解析规则， * 保证批量查重用的分表和入库时路由到的分表是同一张 */ private String formatAdmitDate(String lastEncounterTime) { Date admitDate = parseDate(lastEncounterTime); if (admitDate == null) { return null; } return new SimpleDateFormat("yyyy-MM-dd").format(admitDate); } private Boolean inHospitalDate(List resultList, String cry) { int failCount = 0; for (ServiceSLTDInhospResDTO dto : resultList) { if (Objects.isNull(dto)) continue; try { PatArchive patArchive = processPatientArchive(dto); processPatientInhospInfo(dto, patArchive, cry); } catch (Exception e) { failCount++; log.error("【inHospitalDate】单条记录处理失败，已跳过继续采集。state={}, serialnum={}, patname={}, patno={}, orgid={}, campusId={}", cry, dto.getHealthcareRecordNo(), dto.getPatientName(), dto.getMedicalRecordNo(), dto.getOrgId(), dto.getCampusId(), e); } } if (failCount > 0) { log.warn("【inHospitalDate】本页共{}条，失败{}条已跳过，其余{}条处理完成，state={}", resultList.size(), failCount, resultList.size() - failCount, cry); } return true; } private void processPatientInhospInfo(ServiceSLTDInhospResDTO dto, PatArchive patArchive, String cry) { PatMedInhosp patMedInhosp = buildPatientInhospInfo(dto, patArchive, cry); PatMedInhosp queryInhosp = new PatMedInhosp(); queryInhosp.setPatno(StringUtils.trim(patArchive.getPatientno())); queryInhosp.setSerialnum(StringUtils.trim(patMedInhosp.getSerialnum())); queryInhosp.setOrgid(StringUtils.trim(dto.getOrgId())); queryInhosp.setInhospstate(cry); // log.info("----------------这里的入参为：{},{}", queryInhosp.getPatno(), queryInhosp.getSerialnum()); List existingInhosps = patMedInhospService.selectPatMedInhosp(queryInhosp); if (cry.equals("0")) { //入院数据处理 if (CollectionUtils.isEmpty(existingInhosps)) { //如果为空，要先判断，预入院是否有值，有值的话则更新 queryInhosp.setInhospstate("3"); List patMedInhospList = patMedInhospService.selectPatMedInhosp(queryInhosp); if (CollectionUtils.isNotEmpty(patMedInhospList)) { //如果预入院不为空，则进行修改（预入院→入院） patMedInhosp.setInhospid(patMedInhospList.get(0).getInhospid()); patMedInhospService.updatePatMedInhosp(patMedInhosp); log.info("由预入院更新为入院：serialnum={}", patMedInhosp.getSerialnum()); } else { //如果出院不为空，则不进行处理 queryInhosp.setInhospstate("1"); patMedInhospList = patMedInhospService.selectPatMedInhosp(queryInhosp); if (CollectionUtils.isNotEmpty(patMedInhospList)) { //如果不为空，则将入院时间进行更新 PatMedInhosp pmOut = patMedInhospList.get(0); //本次入院数据（这里 existingInhosps 必为空，取 existingInhosps.get(0) 会下标越界） PatMedInhosp pmIn = patMedInhosp; pmOut.setStarttime(pmIn.getStarttime()); pmOut.setUpdateTime(new Date()); patMedInhospService.updatePatMedInhosp(pmOut); //省立同德需要将开始日期与入院日期相等的任务，改成不执行 try { if ("sltd".equals(active) && DateUtils.isSameDay(pmOut.getStarttime(), pmIn.getEndtime())) { ServiceSubtask serviceSubtask = new ServiceSubtask(); serviceSubtask.setInhospid(pmOut.getInhospid()); serviceSubtask.setSendstate(4L); serviceSubtaskMapper.updateServiceSubtaskByCondition(serviceSubtask); } //通过入院时间，和患者的编号去查一下出院时间，是否存在，如果存在，则该患者是再入院的，需要改成不执行 //出院时间只比较到天，不比较时分秒 if (pmIn.getStarttime() != null) { Date dayStart = DateUtils.truncate(pmIn.getStarttime(), Calendar.DAY_OF_MONTH); Date dayEnd = DateUtils.addDays(dayStart, 1); List outInhosps = inhospVisitFacade.selectOutInhospByPatnoAndOutDate( StringUtils.trim(pmIn.getPatno()), dayStart, dayEnd); if (CollectionUtils.isNotEmpty(outInhosps)) { //存在出院记录，说明该患者是再入院，把上一次出院产生的子任务改成不执行 ServiceSubtask outSubtask = new ServiceSubtask(); outSubtask.setInhospid(outInhosps.get(0).getInhospid()); outSubtask.setSendstate(4L); outSubtask.setRemark("患者再入院"); outSubtask.setUpdateTime(new Date()); serviceSubtaskMapper.updateServiceSubtaskByCondition(outSubtask); log.info("患者再入院，将上次出院记录的子任务改为不执行：patno={}, 出院inhospid={}, 出院时间={}, 本次入院时间={}", pmIn.getPatno(), outInhosps.get(0).getInhospid(), outInhosps.get(0).getEndtime(), pmIn.getStarttime()); } } } catch (Exception e) { log.error("将出院时间等于入院时间的inhospid的任务更新失败了, inhospid={}", pmOut.getInhospid(), e); } return; } } //如果都为空，则进行新增 if (CollectionUtils.isEmpty(patMedInhospList)) { try { patMedInhospService.insertPatMedInhosp(patMedInhosp); } catch (org.springframework.dao.DuplicateKeyException e) { log.warn("入院记录已存在，跳过：serialnum={}, orgid={}, state={}", patMedInhosp.getSerialnum(), patMedInhosp.getOrgid(), patMedInhosp.getInhospstate()); } } } } else if (cry.equals("1")) { // 出院数据处理 if (CollectionUtils.isNotEmpty(existingInhosps)) { // 已存在出院记录，直接更新（保持最新数据） patMedInhosp.setInhospid(existingInhosps.get(0).getInhospid()); patMedInhospService.updatePatMedInhosp(patMedInhosp); log.info("出院记录已存在，执行更新：serialnum={}, orgid={}", patMedInhosp.getSerialnum(), patMedInhosp.getOrgid()); } else { // 不存在出院记录，先查预入院（state=3），再查入院（state=0） queryInhosp.setInhospstate("3"); // log.info("-----查询预入院记录，入参为：{}", queryInhosp); List patMedInhospList = patMedInhospService.selectPatMedInhosp(queryInhosp); log.info("----预入院查询结果：{}", CollectionUtils.isEmpty(patMedInhospList) ? "空" : patMedInhospList.get(0).getSerialnum()); if (CollectionUtils.isNotEmpty(patMedInhospList)) { // 存在预入院记录，更新为出院状态 patMedInhosp.setInhospid(patMedInhospList.get(0).getInhospid()); patMedInhospService.updatePatMedInhosp(patMedInhosp); log.info("由预入院更新为出院：serialnum={}", patMedInhosp.getSerialnum()); } else { // 再查入院记录（state=0） queryInhosp.setInhospstate("0"); patMedInhospList = patMedInhospService.selectPatMedInhosp(queryInhosp); log.debug("入院查询结果：{}", CollectionUtils.isEmpty(patMedInhospList) ? "空" : patMedInhospList.size()); if (CollectionUtils.isNotEmpty(patMedInhospList)) { // 存在入院记录，更新为出院状态 patMedInhosp.setInhospid(patMedInhospList.get(0).getInhospid()); patMedInhospService.updatePatMedInhosp(patMedInhosp); log.info("由入院更新为出院：serialnum={}", patMedInhosp.getSerialnum()); } else { // 预入院和入院均不存在，直接新增出院记录 try { patMedInhospService.insertPatMedInhosp(patMedInhosp); log.info("新增出院记录：serialnum={}", patMedInhosp.getSerialnum()); } catch (org.springframework.dao.DuplicateKeyException e) { log.warn("出院记录已存在，跳过：serialnum={}, orgid={}, state={}", patMedInhosp.getSerialnum(), patMedInhosp.getOrgid(), patMedInhosp.getInhospstate()); } } } } } else if ("3".equals(cry)) { //预入院数据处理：任一状态存在则不新增；都不存在才新增 String serialnum = patMedInhosp.getSerialnum() == null ? "" : patMedInhosp.getSerialnum().trim(); String orgid = patMedInhosp.getOrgid() == null ? "" : patMedInhosp.getOrgid().trim(); String state = patMedInhosp.getInhospstate() == null ? "" : patMedInhosp.getInhospstate(); String lockKey = "inhosp:lock:" + serialnum + ":" + orgid + ":" + state; Boolean locked = false; try { locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS); } catch (Exception e) { log.warn("Redis锁获取失败，降级为直接插入：{}", e.getMessage()); locked = null; // 标记Redis不可用 } if (locked == null || Boolean.TRUE.equals(locked)) { try { queryInhosp.setInhospstate(null); queryInhosp.setSchemestatus(null); queryInhosp.setPatno(null); List patMedInhospList3 = patMedInhospService.selectPatMedInhosp(queryInhosp); if (CollectionUtils.isEmpty(patMedInhospList3)) { try { //获取一下入院申请单 //根据 encounterSourceId 获取 importanceFlagCode emergencyLevelCode if (active.equals("sltd")) { Map applyInfo = hospitalizedApply(dto.getEncounterSourceId(), dto.getOrgId()); if (ObjectUtils.isNotEmpty(applyInfo)) { patMedInhosp.setImportanceFlagCode(applyInfo.get("importanceFlagCode")); patMedInhosp.setEmergencyLevelCode(applyInfo.get("emergencyLevelCode")); } } patMedInhospService.insertPatMedInhosp(patMedInhosp); log.debug("成功插入预入院记录：serialnum={}", patMedInhosp.getSerialnum()); } catch (Exception e) { log.warn("预入院记录插入失败（可能已存在）：serialnum={}, orgid={}, state={}, 错误：{}", patMedInhosp.getSerialnum(), patMedInhosp.getOrgid(), patMedInhosp.getInhospstate(), e.getMessage()); } } } finally { if (Boolean.TRUE.equals(locked)) { try { redisTemplate.delete(lockKey); } catch (Exception e) { log.warn("Redis锁释放失败：{}", e.getMessage()); } } } } else { log.debug("预入院记录正在被其他线程处理，跳过：serialnum={}", patMedInhosp.getSerialnum()); } } } private PatMedInhosp buildPatientInhospInfo(ServiceSLTDInhospResDTO dto, PatArchive patArchive, String cry) { log.info("----------------buildPatientInhospInfo这里进来了吗？{}", cry); PatMedInhosp patMedInhosp = new PatMedInhosp(); patMedInhosp.setPatid(patArchive.getId()); patMedInhosp.setPatno(patArchive.getPatientno()); patMedInhosp.setPatname(patArchive.getName()); patMedInhosp.setNurseId(dto.getChiefNurseId() == null ? "" : dto.getChiefNurseId().toString()); patMedInhosp.setNurseName(dto.getChiefNurseName()); patMedInhosp.setSerialnum(dto.getHealthcareRecordNo()); patMedInhosp.setInhospno(dto.getHealthcareRecordNo()); patMedInhosp.setFuflag("1"); if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) patMedInhosp.setFuflag("0"); if ("0".equals(cry)) { patMedInhosp.setInhospstate("0"); if (CollectionUtils.isNotEmpty(dto.getDiagnosisList()) && dto.getDiagnosisList().size() > 0) { for (ServiceSLTDDiagnosisResDTO diagnosis : dto.getDiagnosisList()) { if (diagnosis.getIsMainDiagnosis() == 1) { patMedInhosp.setDiagname(diagnosis.getDiagnosisDictName() == null ? "" : diagnosis.getDiagnosisDictName()); patMedInhosp.setIcd10code(diagnosis.getDiagnosisDictCode() == null ? "" : diagnosis.getDiagnosisDictCode()); } } } } if ("1".equals(cry)) { patMedInhosp.setInhospstate("1"); ServiceSLTDDiagnosisResDTO mainDischargeDiagnosis = dto.getMainDischargeDiagnosis(); // log.info("-----------mainDischargeDiagnosis的值有了吗?{}", mainDischargeDiagnosis); if (!Objects.isNull(mainDischargeDiagnosis)) { if (mainDischargeDiagnosis.getIsMainDiagnosis() == 1) { patMedInhosp.setLeavediagname(StringUtils.defaultString(mainDischargeDiagnosis.getDiagnosisDictName(), "")); patMedInhosp.setLeaveicd10code(StringUtils.defaultString(mainDischargeDiagnosis.getDiagnosisDictCode(), "")); } } } if ("3".equals(cry)) { patMedInhosp.setInhospstate("3"); if (CollectionUtils.isNotEmpty(dto.getDiagnosisList()) && dto.getDiagnosisList().size() > 0) { for (ServiceSLTDDiagnosisResDTO diagnosis : dto.getDiagnosisList()) { if (diagnosis.getIsMainDiagnosis() == 1) { patMedInhosp.setDiagname(diagnosis.getDiagnosisDictName() == null ? "" : diagnosis.getDiagnosisDictName()); patMedInhosp.setIcd10code(diagnosis.getDiagnosisDictCode() == null ? "" : diagnosis.getDiagnosisDictCode()); } } } } patMedInhosp.setHospitalcode(dto.getOrgId()); patMedInhosp.setBedNo(dto.getBedNumber()); patMedInhosp.setStarttime(parseDate(dto.getStartTime())); patMedInhosp.setEndtime(parseDate(dto.getPreOutHospitalDate())); if ("1".equals(cry)) { setDischargeInfo(patMedInhosp, dto); } else { setAdmissionInfo(patMedInhosp, dto); patMedInhosp.setEncounterSourceId(dto.getEncounterSourceId() == null ? "" : dto.getEncounterSourceId()); if (StringUtils.isNotEmpty(dto.getEncounterSourceId()) && active.equals("sltd")) { //根据 encounterSourceId 获取 importanceFlagCode emergencyLevelCode Map applyInfo = hospitalizedApply(dto.getEncounterSourceId(), dto.getOrgId()); if (!Objects.isNull(applyInfo)) { patMedInhosp.setImportanceFlagCode(applyInfo.get("importanceFlagCode")); patMedInhosp.setEmergencyLevelCode(applyInfo.get("emergencyLevelCode")); } } } patMedInhosp.setDrname(dto.getDoctorName()); patMedInhosp.setDrcode("" + dto.getDoctorId()); patMedInhosp.setSchemestatus("0".equals(cry) ? 1L : 2L); patMedInhosp.setDelFlag("0"); patMedInhosp.setOrgid(dto.getOrgId()); patMedInhosp.setCampusid(dto.getCampusId()); if (StringUtils.isNotEmpty(dto.getHealthcareRecordStatus()) && dto.getHealthcareRecordStatus().equals("FH0109.25")) patMedInhosp.setRemark("预出院"); if (active.equals("nhfy") && dto.getAreaId() != null && dto.getAreaId().toString().equals("40003483") && StringUtils.isNotEmpty(patMedInhosp.getPatname())) { //南华附一的产科，要求不生成“之子、之女、之婴”的随访任务 if (patMedInhosp.getPatname().contains("之子") || patMedInhosp.getPatname().contains("之女") || patMedInhosp.getPatname().contains("之婴")) { patMedInhosp.setDeptcheckFlag("3"); patMedInhosp.setWardcheckFlag("3"); patMedInhosp.setDiagcheckFlag("3"); patMedInhosp.setRemark(patMedInhosp.getRemark() + ";不生成之子、之女、之婴问卷"); } } //目前只有省立同德 if (active.equals("sltd")) { Map drugInfoMap = queryMedicalOrders(dto); if (drugInfoMap != null && !drugInfoMap.isEmpty()) { patMedInhosp.setMedicalName(drugInfoMap.get("drugItemNames")); patMedInhosp.setMedicalCode(drugInfoMap.get("drugItemIds")); patMedInhosp.setMedicalCompany(drugInfoMap.get("drugManufacturerNames")); log.info("获取药品信息成功：名称={}, 编码={}, 厂家={}", drugInfoMap.get("drugItemNames"), drugInfoMap.get("drugItemIds"), drugInfoMap.get("drugManufacturerNames")); } } return patMedInhosp; } /** * 查询医嘱信息并拼接药品信息 * * @param dto 健康记录请求对象 * @return 返回包含三个字段 Map： * - drugItemNames: 药品名称列表（逗号分隔） * - drugItemIds: 药品编码列表（逗号分隔） * - drugManufacturerNames: 药品厂家列表（逗号分隔） *

* 规则： * 1. 三个字段顺序位置保持一致 * 2. 如果三个字段都为空，则跳过该记录 * 3. 如果至少有一个字段有值，则其他两个为空用空字符串代替 */ private Map queryMedicalOrders(ServiceSLTDInhospResDTO dto) { Map result = new HashMap<>(); List itemNames = new ArrayList<>(); List itemIds = new ArrayList<>(); List manufacturerNames = new ArrayList<>(); try { // 获取患者的医嘱信息 Map medicineInfoReq = new HashMap<>(); medicineInfoReq.put("orgId", dto.getOrgId()); medicineInfoReq.put("patientId", dto.getPatientId()); medicineInfoReq.put("campusId", dto.getCampusId()); medicineInfoReq.put("medicalRecordNo", dto.getMedicalRecordNo()); log.info("【queryMedicalOrders】请求参数：{}", medicineInfoReq); Map headers = buildRequestHeaders(); String resultStr = HttpUtils.sendPostByHeader(sltdPubPath + "/osj/hbos-thirdparty-integration/standard/common/doctorOrder/queryDoctorOrderList", new Gson().toJson(medicineInfoReq), headers); if (StringUtils.isEmpty(resultStr)) { log.warn("【queryMedicalOrders】接口返回为空，patientId={}", dto.getPatientId()); return result; } // 解析返回数据 Gson gson = new Gson(); Type mapType = new TypeToken>() { }.getType(); Map responseMap = gson.fromJson(resultStr, mapType); // 检查返回码 Object codeObj = responseMap.get("code"); if (codeObj != null) { String code = BigDecimal.valueOf(((Number) codeObj).longValue()).toPlainString(); if (!"200".equals(code)) { log.error("【queryMedicalOrders】接口返回失败，code={}, message={}", code, responseMap.get("message")); return null; } } // 获取 data 数组 Object dataObj = responseMap.get("data"); if (dataObj instanceof List) { List dataList = (List) dataObj; // 遍历医嘱列表，提取药品信息 Set processedItemIds = new HashSet<>(); // 用于去重（只根据 itemId 去重） for (Object item : dataList) { if (item instanceof Map) { Map itemMap = (Map) item; // 只处理药品相关的医嘱（itemDomain 为 FH0134.01 表示药品） Object itemDomainObj = itemMap.get("itemDomain"); if (itemDomainObj == null || !"FH0134.01".equals(itemDomainObj.toString())) { continue; } // 获取三个字段 Object itemNameObj = itemMap.get("itemName"); Object itemIdObj = itemMap.get("itemId"); Object manufacturerNameObj = itemMap.get("manufacturerName"); // 判断是否都为空 boolean allEmpty = (itemNameObj == null || StringUtils.isEmpty(itemNameObj.toString())) && (itemIdObj == null || StringUtils.isEmpty(itemIdObj.toString())) && (manufacturerNameObj == null || StringUtils.isEmpty(manufacturerNameObj.toString())); // 如果三个都为空，则跳过 if (allEmpty) { continue; } // 至少有一个有值，处理每个字段 String itemName = (itemNameObj != null && StringUtils.isNotEmpty(itemNameObj.toString())) ? itemNameObj.toString() : ""; // itemId 特殊处理：避免科学计数法（Gson 可能将数字解析为 Double） String itemId = ""; if (itemIdObj != null && StringUtils.isNotEmpty(itemIdObj.toString())) { if (itemIdObj instanceof Number) { // 如果是数值类型，转换为整数字符串，避免科学计数法 itemId = String.valueOf(((Number) itemIdObj).longValue()); } else { itemId = itemIdObj.toString(); } } String manufacturerName = (manufacturerNameObj != null && StringUtils.isNotEmpty(manufacturerNameObj.toString())) ? manufacturerNameObj.toString() : ""; // 只根据 itemId 去重（同一编码的药品只保留一个） if (StringUtils.isNotEmpty(itemId)) { if (processedItemIds.contains(itemId)) { log.info("【queryMedicalOrders】跳过重复药品（相同编码）：名称={}, 编码={}", itemName, itemId); continue; } processedItemIds.add(itemId); } else { // itemId 为空时，使用 itemName 作为去重依据 if (processedItemIds.contains(itemName)) { log.info("【queryMedicalOrders】跳过重复药品（相同名称）：名称={}", itemName); continue; } processedItemIds.add(itemName); } // 添加到列表 itemNames.add(itemName); itemIds.add(itemId); manufacturerNames.add(manufacturerName); log.info("【queryMedicalOrders】提取药品信息：名称={}, 编码={}, 厂家={}", itemName, itemId, manufacturerName); } } } else { log.info("【queryMedicalOrders】data 不是数组类型，patientId={}", dto.getPatientId()); } // 将列表拼接成逗号分隔的字符串 if (!itemNames.isEmpty()) { result.put("drugItemNames", String.join(",", itemNames)); result.put("drugItemIds", String.join(",", itemIds)); result.put("drugManufacturerNames", String.join(",", manufacturerNames)); } log.info("【queryMedicalOrders】成功提取{}条药品信息，patientId={}", itemNames.size(), dto.getPatientId()); } catch (Exception e) { log.error("【queryMedicalOrders】查询医嘱信息失败，patientId={}", dto.getPatientId(), e); } return result; } private void setDischargeInfo(PatMedInhosp patMedInhosp, ServiceSLTDInhospResDTO dto) { patMedInhosp.setLeaveldeptcode("" + dto.getDeptId()); patMedInhosp.setLeaveldeptname(dto.getDeptName()); patMedInhosp.setLeavediagname(dto.getMainDischargeDiagnosis() == null ? null : dto.getMainDischargeDiagnosis().getDiagnosisDictName()); patMedInhosp.setLeaveicd10code(dto.getMainDischargeDiagnosis() == null ? null : dto.getMainDischargeDiagnosis().getDiagnosisDictCode()); patMedInhosp.setOutWayId(null); patMedInhosp.setOutWayName(null); patMedInhosp.setLeavehospitaldistrictid("" + dto.getAreaId()); patMedInhosp.setLeavehospitaldistrictcode("" + dto.getAreaId()); patMedInhosp.setLeavehospitaldistrictname(dto.getAreaName()); patMedInhosp.setLeaveldeptid("" + dto.getDeptId()); } private void setAdmissionInfo(PatMedInhosp patMedInhosp, ServiceSLTDInhospResDTO dto) { patMedInhosp.setDeptcode("" + dto.getDeptId()); patMedInhosp.setDeptname(dto.getDeptName()); patMedInhosp.setDiagname(dto.getAdmissionDiagnosisName()); patMedInhosp.setIcd10code(dto.getAdmissionDiagnosisCode()); patMedInhosp.setHospitaldistrictid("" + dto.getAreaId()); patMedInhosp.setHospitaldistrictcode("" + dto.getAreaId()); patMedInhosp.setHospitaldistrictname(dto.getAreaName()); } /** * 根据入院申请单ID查询入院申请单详情 * 只提取 importanceFlagCode（importanceFlagCodeList逗号拼接）和 emergencyLevelCode 两个值 */ private Map hospitalizedApply(String encounterSourceId, String orgid) { Map applyInfo = new HashMap<>(); Map headers = buildRequestHeaders(); log.info("院申请单ID查询入院申请单：{},appKey:{}", sltdPubPath + "/sf/hospitalizedApply/query", APP_KEY); //设置入参 Map requestParams = new HashMap<>(); requestParams.put("applyId", encounterSourceId); requestParams.put("orgId", orgid); String result = null; if (StringUtils.isNotEmpty(encounterSourceId) && StringUtils.isNotEmpty(orgid)) result = HttpUtils.sendPostByHeader(sltdPubPath + "/sf/hospitalizedApply/query", new Gson().toJson(requestParams), headers); if (StringUtils.isEmpty(result)) { log.error("【hospitalizedApply】接口返回为空，applyId={}", encounterSourceId); return applyInfo; } try { Gson gson = new Gson(); Type mapType = new TypeToken>() { }.getType(); Map responseMap = gson.fromJson(result, mapType); Object dataObj = responseMap == null ? null : responseMap.get("data"); if (dataObj instanceof Map) { Map data = (Map) dataObj; //重要性标记编码，接口返回是数组，需要转换为字典名称 Object importanceFlagCodeListObj = data.get("importanceFlagCodeList"); if (importanceFlagCodeListObj instanceof List) { List importanceFlagCodeList = (List) importanceFlagCodeListObj; // 过滤掉 null 值 List nonNullList = importanceFlagCodeList.stream().filter(Objects::nonNull).map(Object::toString).filter(StringUtils::isNotEmpty).collect(Collectors.toList()); if (!nonNullList.isEmpty()) { String importanceFlagLabel; if (nonNullList.size() == 1) { // 只有一个值，直接通过枚举获取描述 importanceFlagLabel = ImportFlagEnum.getDescByCode(nonNullList.get(0)); } else { // 多个值，用逗号拼接枚举描述 StringBuilder labelBuilder = new StringBuilder(); for (String code : nonNullList) { String label = ImportFlagEnum.getDescByCode(code); if (StringUtils.isNotEmpty(label)) { labelBuilder.append(label).append(","); } } importanceFlagLabel = StringUtils.stripEnd(labelBuilder.toString(), ","); } if (StringUtils.isNotEmpty(importanceFlagLabel)) { applyInfo.put("importanceFlagCode", importanceFlagLabel); } } } //紧急程度编码，通过枚举转换描述 Object emergencyLevelCodeObj = data.get("emergencyLevelCode"); if (emergencyLevelCodeObj != null) { String emergencyLevelLabel = EmergencyLevelEnum.getDescByCode(emergencyLevelCodeObj.toString()); if (StringUtils.isNotEmpty(emergencyLevelLabel)) { applyInfo.put("emergencyLevelCode", emergencyLevelLabel); } } } else { log.error("【hospitalizedApply】接口返回data不是对象，applyId={}，result：{}", encounterSourceId, result); } } catch (Exception e) { log.error("【hospitalizedApply】解析入院申请单详情失败，applyId={}", encounterSourceId, e); } log.info("【hospitalizedApply】applyId={}，importanceFlagCode={}，emergencyLevelCode={}", encounterSourceId, applyInfo.get("importanceFlagCode"), applyInfo.get("emergencyLevelCode")); return applyInfo; } /** * 处理患者档案（新增或更新） * 使用 Redis 分布式锁防止并发重复插入 */ private PatArchive processPatientArchive(ServiceSLTDInhospResDTO dto) { // 构建锁的 key：基于 patientno 或 idcardno String lockKey = "pat_archive_lock:" + (StringUtils.isNotEmpty(dto.getMedicalRecordNo()) ? dto.getMedicalRecordNo() : dto.getIdCardNo()); // 尝试获取分布式锁，最多等待 3 秒，锁定 10 秒自动释放 Boolean lockAcquired = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS); if (lockAcquired == null || !lockAcquired) { log.warn("【processPatientArchive】获取分布式锁失败，跳过本次处理（其他线程正在处理），patientno={}", dto.getMedicalRecordNo()); // 等待一段时间后重试查询 try { Thread.sleep(500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } try { return doProcessPatientArchive(dto); } finally { // 释放锁 if (lockAcquired != null && lockAcquired) { redisTemplate.delete(lockKey); } } } /** * 实际执行患者档案处理逻辑 */ private PatArchive doProcessPatientArchive(ServiceSLTDInhospResDTO dto) { List existingArchives = null; log.info("【processPatientArchive】新增患者档案，查询入参信息patientno:{}，idcardno:{}", dto.getMedicalRecordNo(), dto.getIdCardNo()); // 第一步：按 patientno 精确查重（与插入时使用的 medicalRecordNo 一致） String patientno = StringUtils.isEmpty(dto.getMedicalRecordNo()) ? null : dto.getMedicalRecordNo(); if (StringUtils.isNotEmpty(patientno)) { PatArchive queryByPatientNo = new PatArchive(); queryByPatientNo.setPatientno(patientno); existingArchives = patArchiveService.selectPatArchiveList(queryByPatientNo); log.debug("【processPatientArchive】按patientno查询，patientno={}, 结果数量={}", patientno, existingArchives.size()); } // 第二步：按 patientno 查不到时，按 idcardno 查重（分步OR，避免AND条件漏查） if (CollectionUtils.isEmpty(existingArchives) && StringUtils.isNotEmpty(dto.getIdCardNo())) { PatArchive queryByIdCard = new PatArchive(); queryByIdCard.setIdcardno(dto.getIdCardNo().trim()); existingArchives = patArchiveService.selectPatArchiveList(queryByIdCard); log.debug("【processPatientArchive】按idcardno查询，idcardno={}, 结果数量={}", dto.getIdCardNo(), existingArchives.size()); } PatArchive patArchive = buildPatientArchive(dto); log.info("【processPatientArchive】患者档案查重完成，patientno={}, 是否已存在={}", patArchive.getPatientno(), CollectionUtils.isEmpty(existingArchives) ? "否" : "是(id=" + existingArchives.get(0).getId() + ")"); if (CollectionUtils.isEmpty(existingArchives)) { try { // 最终确认查询（防御性编程：防止Redis锁失效等极端情况） PatArchive finalQuery = new PatArchive(); if (StringUtils.isNotEmpty(dto.getIdCardNo())) { finalQuery.setIdcardno(dto.getIdCardNo().trim()); } if (StringUtils.isNotEmpty(dto.getMedicalRecordNo())) { finalQuery.setPatientno(dto.getMedicalRecordNo()); } List finalCheck = patArchiveService.selectPatArchiveList(finalQuery); log.info("【processPatientArchive】最终确认查询，patientno={}, idcardno={}, 结果数量={}", dto.getMedicalRecordNo(), dto.getIdCardNo(), finalCheck.size()); if (CollectionUtils.isEmpty(finalCheck)) { patArchiveService.insertPatArchive(patArchive); log.info("【processPatientArchive】✓ 新增患者档案成功，patientno={}, id={}", patArchive.getPatientno(), patArchive.getId()); } else { // 其他线程已经插入，直接使用已有记录 existingArchives = finalCheck; patArchive.setId(existingArchives.get(0).getId()); patArchive.setNotrequiredFlag(existingArchives.get(0).getNotrequiredFlag()); patArchive.setNotrequiredreason(existingArchives.get(0).getNotrequiredreason()); log.info("【processPatientArchive】档案已被其他线程创建，使用已有记录，id={}", patArchive.getId()); } } catch (org.springframework.dao.DuplicateKeyException e) { log.warn("【processPatientArchive】患者档案已存在(并发插入异常)，跳过：patientno={}, idcardno={}", patArchive.getPatientno(), patArchive.getIdcardno()); // 并发插入场景，重新查询获取已存在的记录 PatArchive queryRetry = new PatArchive(); queryRetry.setPatientno(patArchive.getPatientno()); if (StringUtils.isNotEmpty(patArchive.getIdcardno())) { queryRetry.setIdcardno(patArchive.getIdcardno()); } existingArchives = patArchiveService.selectPatArchiveList(queryRetry); if (CollectionUtils.isNotEmpty(existingArchives)) { patArchive.setId(existingArchives.get(0).getId()); patArchive.setNotrequiredFlag(existingArchives.get(0).getNotrequiredFlag()); patArchive.setNotrequiredreason(existingArchives.get(0).getNotrequiredreason()); log.info("【processPatientArchive】从异常恢复，获取已有档案，id={}", patArchive.getId()); } } } else { patArchive.setId(existingArchives.get(0).getId()); patArchive.setNotrequiredFlag(existingArchives.get(0).getNotrequiredFlag()); patArchive.setNotrequiredreason(existingArchives.get(0).getNotrequiredreason()); patArchiveService.updateArchive(patArchive); log.info("【processPatientArchive】✓ 更新患者档案，patientno={}, id={}", patArchive.getPatientno(), patArchive.getId()); } return patArchive; } private PatArchive buildPatientArchive(ServiceSLTDInhospResDTO dto) { PatArchive patArchive = new PatArchive(); patArchive.setPatientno(StringUtils.isEmpty(dto.getMedicalRecordNo()) ? null : dto.getMedicalRecordNo()); patArchive.setPatidHis(dto.getPatientId() == null ? null : String.valueOf(dto.getPatientId())); patArchive.setIdcardno(StringUtils.isEmpty(dto.getIdCardNo()) ? "" + dto.getMedicalCardId() : dto.getIdCardNo().trim()); patArchive.setName(dto.getPatientName()); patArchive.setSourcefrom(2L); patArchive.setPattype("2"); patArchive.setSex("男".equals(dto.getGender()) ? 1L : 2L); patArchive.setNation(dto.getNation()); patArchive.setNativePlace(dto.getNativePlace()); patArchive.setPlaceOfResidence(dto.getAddress()); patArchive.setBirthdate(parseDate(dto.getBirthday())); patArchive.setTelcode(dto.getPhone()); if (CollectionUtils.isNotEmpty(dto.getResidentContactInfos())) { patArchive.setRelativetelcode(dto.getResidentContactInfos().get(0).getTelecom()); } patArchive.setDelFlag("0"); patArchive.setCreateTime(new Date()); patArchive.setUpdateTime(new Date()); patArchive.setOrgid("" + dto.getOrgId()); patArchive.setCampusid(dto.getCampusId()); return patArchive; } private ServiceSLTDInhospResDTO convertToDTO(Map dataItem) { ServiceSLTDInhospResDTO dto = new ServiceSLTDInhospResDTO(); dto.setOrgId(getStringValue(dataItem, "orgId")); dto.setCampusId(getStringValue(dataItem, "campusId")); dto.setHealthcareRecordId(getLongValue(dataItem, "healthcareRecordId")); dto.setHealthcareRecordNo(getStringValue(dataItem, "healthcareRecordNo")); dto.setPatientId(getLongValue(dataItem, "patientId")); dto.setPatientName(getStringValue(dataItem, "patientName")); dto.setPinyin(getStringValue(dataItem, "pinyin")); dto.setNation(getStringValue(dataItem, "nation")); dto.setIdCardNo(getStringValue(dataItem, "idCardNo")); dto.setHealthcareRecordTimes(getIntegerValue(dataItem, "healthcareRecordTimes")); dto.setHospitalizationNumber(getIntegerValue(dataItem, "hospitalizationNumber")); dto.setMedicalCardId(getLongValue(dataItem, "medicalCardId")); dto.setMedicalCardType(getStringValue(dataItem, "medicalCardType")); dto.setMedicalCardTypeName(getStringValue(dataItem, "medicalCardTypeName")); dto.setMedicalCardNo(getStringValue(dataItem, "medicalCardNo")); dto.setMedicalRecordNo(getStringValue(dataItem, "medicalRecordNo")); dto.setGender(getStringValue(dataItem, "gender")); dto.setGenderCode(getStringValue(dataItem, "genderCode")); dto.setAge(getStringValue(dataItem, "age")); dto.setBirthday(getStringValue(dataItem, "birthday")); dto.setPhone(getStringValue(dataItem, "phone")); dto.setEducation(getStringValue(dataItem, "education")); dto.setEducationCode(getStringValue(dataItem, "educationCode")); dto.setNeonatal(getBooleanValue(dataItem, "neonatal")); dto.setMarriage(getStringValue(dataItem, "marriage")); dto.setMarriageCode(getStringValue(dataItem, "marriageCode")); dto.setOccupationType(getStringValue(dataItem, "occupationType")); dto.setOccupationTypeCode(getStringValue(dataItem, "occupationTypeCode")); dto.setNativePlace(getStringValue(dataItem, "nativePlace")); dto.setAreaId(getLongValue(dataItem, "areaId")); dto.setAreaName(getStringValue(dataItem, "areaName")); dto.setRoomId(getLongValue(dataItem, "roomId")); dto.setRoomNumber(getStringValue(dataItem, "roomNumber")); dto.setBedId(getLongValue(dataItem, "bedId")); dto.setBedNumber(getStringValue(dataItem, "bedNumber")); dto.setEncounterTime(getStringValue(dataItem, "encounterTime")); dto.setStartTime(getStringValue(dataItem, "startTime")); dto.setPreOutHospitalDate(getStringValue(dataItem, "preOutHospitalDate")); dto.setLastEncounterTime(getStringValue(dataItem, "lastEncounterTime")); dto.setDiagnosisCode(getStringValue(dataItem, "diagnosisCode")); dto.setDiagnosisName(getStringValue(dataItem, "diagnosisName")); dto.setHealthcareRecordStatus(getStringValue(dataItem, "healthcareRecordStatus")); dto.setHealthcareType(getStringValue(dataItem, "healthcareType")); dto.setDeptId(getLongValue(dataItem, "deptId")); dto.setDeptName(getStringValue(dataItem, "deptName")); dto.setDoctorId(getLongValue(dataItem, "doctorId")); dto.setDoctorName(getStringValue(dataItem, "doctorName")); dto.setHealthcarePeriodId(getLongValue(dataItem, "healthcarePeriodId")); dto.setChiefNurseId(getLongValue(dataItem, "chiefNurseId")); dto.setChiefNurseName(getStringValue(dataItem, "chiefNurseName")); dto.setCostCategoryName(getStringValue(dataItem, "costCategoryName")); dto.setCostCategoryCode(getStringValue(dataItem, "costCategoryCode")); dto.setCostNatureName(getStringValue(dataItem, "costNatureName")); dto.setCostNatureCode(getStringValue(dataItem, "costNatureCode")); dto.setEncounterSourceId(getStringValue(dataItem, "encounterSourceId")); dto.setFurtherConsultationStatus(getIntegerValue(dataItem, "furtherConsultationStatus")); Object mainDiagObj = dataItem.get("mainDischargeDiagnosis"); if (mainDiagObj instanceof Map) { Map mainDiagMap = (Map) mainDiagObj; ServiceSLTDDiagnosisResDTO mainDiag = new ServiceSLTDDiagnosisResDTO(); mainDiag.setDiagnosisDictCode(getStringValue(mainDiagMap, "diagnosisDictCode")); mainDiag.setDiagnosisDictName(getStringValue(mainDiagMap, "diagnosisDictName")); mainDiag.setDiagnosisCategory(getStringValue(mainDiagMap, "diagnosisCategory")); mainDiag.setRecordType(getIntegerValue(mainDiagMap, "recordType")); mainDiag.setIsMainDiagnosis(getIntegerValue(mainDiagMap, "isMainDiagnosis")); dto.setMainDischargeDiagnosis(mainDiag); } Object contactsObj = dataItem.get("residentContactInfos"); if (contactsObj instanceof List) { dto.setResidentContactInfos(parseContacts((List) contactsObj)); } Object diagnosisObj = dataItem.get("diagnosisList"); if (diagnosisObj instanceof List) { dto.setDiagnosisList(parseDiagnosis((List) diagnosisObj)); } return dto; } private MedicationItem convertToMedication(Map dataItem) { MedicationItem dto = new MedicationItem(); dto.setOrgId(getLongValue(dataItem, "orgId")); dto.setIdentificationCode(getStringValue(dataItem, "identificationCode")); dto.setWbm(getStringValue(dataItem, "wbm")); dto.setMedicationCommonName(getStringValue(dataItem, "medicationCommonName")); dto.setManufacturerName(getStringValue(dataItem, "manufacturerName")); dto.setItemCode(getStringValue(dataItem, "itemCode")); dto.setSmallLargePackageRatio(getLongValue(dataItem, "smallLargePackageRatio")); dto.setRemark(getStringValue(dataItem, "remark")); dto.setItemName(getStringValue(dataItem, "itemName")); dto.setMedicationType(getStringValue(dataItem, "medicationType")); Object mainDiagObj = dataItem.get("doseInfoList"); List doseInfoList = new ArrayList<>(); if (mainDiagObj instanceof List) { List> mainDiagList = (List>) mainDiagObj; for (Map mainDiagMap : mainDiagList) { MedicationDoseInfo medicationDoseInfo = new MedicationDoseInfo(); medicationDoseInfo.setDoseSmallPackageRation(getBigDecimalValue(mainDiagMap, "doseSmallPackageRation")); medicationDoseInfo.setDose(getLongValue(mainDiagMap, "dose")); medicationDoseInfo.setDoseSmallPackageNum(getLongValue(mainDiagMap, "doseSmallPackageNum")); medicationDoseInfo.setDoseUnit(getStringValue(mainDiagMap, "doseUnit")); medicationDoseInfo.setDoseUnitType(getLongValue(mainDiagMap, "doseUnitType")); doseInfoList.add(medicationDoseInfo); } } dto.setDoseInfoList(doseInfoList); dto.setAntimicrobialGradeCode(getStringValue(dataItem, "antimicrobialGradeCode")); dto.setLicenseNumber(getStringValue(dataItem, "licenseNumber")); dto.setDefaultUsageName(getStringValue(dataItem, "defaultUsageName")); dto.setSpecialDrugsName(getStringValue(dataItem, "specialDrugsName")); dto.setAntimicrobialGradeName(getStringValue(dataItem, "antimicrobialGradeName")); dto.setCommonPinyin(getStringValue(dataItem, "commonPinyin")); dto.setCommonWbm(getStringValue(dataItem, "commonWbm")); dto.setManufacturerId(getLongValue(dataItem, "manufacturerId")); dto.setDefaultUsageId(getLongValue(dataItem, "defaultUsageId")); dto.setSpecification(getStringValue(dataItem, "specification")); dto.setSmallPackageUnit(getStringValue(dataItem, "smallPackageUnit")); dto.setItemId(getLongValue(dataItem, "itemId")); dto.setSpecialDrugsCode(getStringValue(dataItem, "specialDrugsCode")); dto.setPinyin(getStringValue(dataItem, "pinyin")); dto.setDoseFormName(getStringValue(dataItem, "doseFormName")); dto.setLargePackageUnit(getStringValue(dataItem, "largePackageUnit")); dto.setRetailPrice(getBigDecimalValue(dataItem, "retailPrice")); dto.setStatus(getLongValue(dataItem, "status")); return dto; } private List parseContacts(List contactsList) { List contacts = new ArrayList<>(); for (Object contactObj : contactsList) { if (contactObj instanceof Map) { Map contactMap = (Map) contactObj; ServiceSLTDContactsResDTO contact = new ServiceSLTDContactsResDTO(); contact.setName(getStringValue(contactMap, "name")); contact.setRelationshipCode(getStringValue(contactMap, "relationshipCode")); contact.setRelationship(getStringValue(contactMap, "relationship")); contact.setTelecom(getStringValue(contactMap, "telecom")); contact.setCurrentAddress(getStringValue(contactMap, "currentAddress")); contacts.add(contact); } } return contacts; } private List parseDiagnosis(List diagnosisList) { List diagnosis = new ArrayList<>(); for (Object diagnosisObj : diagnosisList) { if (diagnosisObj instanceof Map) { Map diagnosisMap = (Map) diagnosisObj; ServiceSLTDDiagnosisResDTO diag = new ServiceSLTDDiagnosisResDTO(); diag.setDiagnosisDictCode(getStringValue(diagnosisMap, "diagnosisDictCode")); diag.setDiagnosisDictName(getStringValue(diagnosisMap, "diagnosisDictName")); diag.setDiagnosisCategory(getStringValue(diagnosisMap, "diagnosisCategory")); diag.setRecordType(getIntegerValue(diagnosisMap, "recordType")); diag.setIsMainDiagnosis(getIntegerValue(diagnosisMap, "isMainDiagnosis")); diagnosis.add(diag); } } return diagnosis; } private String getStringValue(Map map, String key) { Object value = map.get(key); if (value == null) { return null; } // 只处理数字类型，避免科学计数法 return value instanceof Number ? new BigDecimal(value.toString()).toPlainString() : value.toString(); } private BigDecimal getBigDecimalValue(Map map, String key) { Object value = map.get(key); if (value == null) { return null; } // 只处理数字类型，避免科学计数法 return new BigDecimal(value.toString()); } private Long getLongValue(Map map, String key) { Object value = map.get(key); if (value == null) return null; if (value instanceof Number) { return ((Number) value).longValue(); } try { return Long.parseLong(value.toString()); } catch (NumberFormatException e) { return null; } } private Integer getIntegerValue(Map map, String key) { Object value = map.get(key); if (value == null) return null; if (value instanceof Number) { return ((Number) value).intValue(); } try { return Integer.parseInt(value.toString()); } catch (NumberFormatException e) { return null; } } private Boolean getBooleanValue(Map map, String key) { Object value = map.get(key); if (value == null) return null; if (value instanceof Boolean) { return (Boolean) value; } return Boolean.parseBoolean(value.toString()); } }