Merge branch 'master' into master-手术随访

陈昶聿

4 天以前 3f8535e2eeab1463324438f28d2ef72d8f1049c9

 smartor/src/main/java/com/smartor/service/impl/ServiceSLTDHealthcareRecordServiceImpl.java

@@ -10,10 +10,12 @@
import com.ruoyi.common.core.domain.entity.SysUserRole;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.http.HttpUtils;
import com.smartor.common.DistinctByProperty;
import com.smartor.domain.*;
import com.smartor.mapper.*;
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;
@@ -30,6 +32,8 @@
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.Collectors;

@Slf4j
@Service
@@ -45,7 +49,7 @@
    private IPatMedInhospService patMedInhospService;

    @Autowired
    private PatMedOuthospMapper patMedOuthospMapper;
    private IPatMedOuthospService patMedOuthospService;

    @Autowired
    private SysUser2Mapper sysUser2Mapper;
@@ -389,6 +393,13 @@
        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;
    }

@@ -446,11 +457,21 @@
    }

    private void processResultList(List<ServiceSLTDInhospResDTO> resultList, List<String> types, String cry, String campusId) {
        for (String type : types)
        // 门诊(FH0108.01)和急诊(FH0108.03)在业务上是同一类数据，共用同一个 resultList。
        // 若 types 同时包含两者，outHospitalDate 会被调用两次导致重复入库。
        // 因此只要 types 中含有任意一个门急诊类型，就只处理一次。
        boolean outpProcessed = false;
        for (String type : types) {
            switch (type) {
                case "FH0108.01":
                    log.info("【parseResponseData】解析门诊数据");
                    outHospitalDate(resultList);
                case "FH0108.03":
                    if (!outpProcessed) {
                        log.info("【parseResponseData】解析门急诊数据，types={}", types);
                        outHospitalDate(resultList);
                        outpProcessed = true;
                    } else {
                        log.info("【parseResponseData】门急诊数据已处理，跳过 type={}", type);
                    }
                    break;
                case "FH0109.26":
                    log.info("【parseResponseData】解析住院数据");
@@ -472,19 +493,16 @@
                    log.info("【parseResponseData】解析预住院（其他）数据");
                    inHospitalDate(resultList, cry);
                    break;
//                case "FH0108.03":
//                    log.info("【parseResponseData】解析急诊数据");
//                    outHospitalDate(resultList);
//                    break;
                default:
                    log.warn("【parseResponseData】未知的数据类型：{}", type);
                    break;
            }
        }
    }

    private Boolean outHospitalDate(List<ServiceSLTDInhospResDTO> resultList) {
        List<PatMedOuthosp> batchList = new ArrayList<>();
        

        for (ServiceSLTDInhospResDTO dto : resultList) {
            if (Objects.isNull(dto)) {
                continue;
@@ -493,22 +511,21 @@
            PatMedOuthosp patMedOuthosp = buildPatMedOuthosp(dto, patArchive);
            batchList.add(patMedOuthosp);
        }
        

        // 批量插入，自动忽略重复
        if (CollectionUtils.isNotEmpty(batchList)) {
            try {
                int insertCount = patMedOuthospMapper.batchInsertIgnore(batchList);
                //这里用自动忽略重复会有问题，如果表重新建，serialnum索引会丢失。就无法去重，所以还是需要内存里去重
                batchList = DistinctByProperty.distinctByProperty(batchList, PatMedOuthosp::getSerialnum);
                Integer insertCount = 0;
                for (PatMedOuthosp patMedOuthosp : batchList) {
                    insertCount += patMedOuthospService.insertPatMedOuthosp(patMedOuthosp);
                }

                log.info("批量插入门急诊记录，总数：{}, 实际插入：{}", batchList.size(), insertCount);

            } catch (Exception e) {
                log.error("批量插入门急诊记录失败", e);
                // 降级为逐条插入
                for (PatMedOuthosp patMedOuthosp : batchList) {
                    try {
                        patMedOuthospMapper.insertPatMedOuthosp(patMedOuthosp);
                    } catch (Exception ex) {
                        log.warn("单条插入失败：serialnum={}", patMedOuthosp.getSerialnum());
                    }
                }
            }
        }
        return true;
@@ -597,37 +614,38 @@
            }

        } else if (cry.equals("1")) {
//           出院数据处理
            if (CollectionUtils.isEmpty(existingInhosps)) {
                //如果为空，要先判断，预入院是否有值，有值的话则更新
            // 出院数据处理
            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("-----patMedInhospList进来了不？入参为：{}", queryInhosp);
                log.info("-----查询预入院记录，入参为：{}", queryInhosp);
                List<PatMedInhosp> patMedInhospList = patMedInhospService.selectPatMedInhosp(queryInhosp);
                log.info("----patMedInhospList进来了不？返参为：{}", CollectionUtils.isEmpty(patMedInhospList) ? null : patMedInhospList.get(0).getSerialnum());
                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);
                    }
                }

                //如果都为空，则进行新增
                if (CollectionUtils.isEmpty(patMedInhospList)) {
                    //如果入院不为空，则进行修改
                    queryInhosp.setInhospstate("0");
                    log.debug("出院queryInhosp入参为：{}", queryInhosp);
                    List<PatMedInhosp> patMedInhosps = patMedInhospService.selectPatMedInhosp(queryInhosp);
                    log.debug("出院patMedInhospList返参为：{}", CollectionUtils.isEmpty(patMedInhosps) ? null : patMedInhosps.size());
                    if (CollectionUtils.isNotEmpty(patMedInhosps)) {
                        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());
                        }
@@ -756,7 +774,7 @@
        patArchive.setPatientno("" + dto.getPatientId());
        patArchive.setIdcardno(StringUtils.isEmpty(dto.getIdCardNo()) ? "" + dto.getMedicalCardId() : dto.getIdCardNo().trim());
        patArchive.setName(dto.getPatientName());
        patArchive.setSourcefrom(2);
        patArchive.setSourcefrom(2L);
        patArchive.setPattype("2");
        patArchive.setSex("男".equals(dto.getGender()) ? 1L : 2L);
        patArchive.setNation(dto.getNation());