ai优化

yxh

8 天以前 68ff33beff11310e830b0615b5a81f83fad0f683

 jh-module-ecg/jh-module-ecg-biz/src/main/java/cn/lihu/jh/module/ecg/service/devrent/DevRentServiceImpl.java

@@ -85,6 +85,9 @@
    @Autowired
    private WebServiceClient webServiceClient;

    /** 【本需求】紧急加做的备注标记，便于在完成列表/报表里区分这类"不排队直接检查"的记录 */
    private static final String EMERGENCY_REMARK = "紧急加做";


    @Override
    public CommonResult<Long> registerOperation(DevRentSaveReqVO createReqVO) {
@@ -101,6 +104,13 @@
        String userNickname = SecurityFrameworkUtils.getLoginUserNickname();
        String userHisId = SecurityFrameworkUtils.getLoginUserHisId();

        // 【本需求：紧急患者不排队直接检查】
        // 正常患者的「待检查(0)」检查单是签到建队列时一起插的；紧急加做的患者没走签到，
        // 因此这里先把这条单补出来，后续逻辑（写作业记录、更新队列、回写集成平台）完全复用。
        if (Boolean.TRUE.equals(routineFinishReqVO.getEmergency())) {
            prepareEmergencyDevRent(routineFinishReqVO, createReqVO);
        }

        // 在预约确认时 就进入 [dev_rent] 表了
        Long rent_id = createReqVO.getId();

@@ -110,33 +120,64 @@
        JobRecordDO jobRecordDO = jobRecordMapper.selectByRentIdDocId(rent_id, userId, jobTypeList);
        if (null == jobRecordDO) {
            List<DevRentDO> devRentDOList = devRentMapper.selectByPatAndChecktypeAndState(createReqVO.getPatId(), createReqVO.getCheckType(), DevRentStateEnum.FREE.getState());
            if (devRentDOList.size() == 0) throw exception(DEV_INSTALL_NOT_APPOINTMENT);
            else if (devRentDOList.size() != 1) {
                throw exception(DEV_INSTALL_EXCEPTION);

            // 【本次修复】撤销后再次完成时的兜底：
            // 若「待检查(0)」的单子不存在（撤销时没能回滚到 0、或历史数据），
            // 不能再直接报「请先预约确认」，否则医生无法把误完成的患者重新完成。
            // 这里复用**今日最近一条**「常规检查完成(60)/常规检查放弃(50)」的单；
            // 且如果该单已经有完成记录，就走下面的"更新"分支，避免重复插入 job_record。
            if (devRentDOList.isEmpty()) {
                List<Integer> fallbackStateList = new ArrayList<>();
                fallbackStateList.add(DevRentStateEnum.ROUTINE_FINISH.getState());
                fallbackStateList.add(DevRentStateEnum.ROUTINE_CANCELLED.getState());
                DevRentDO fallbackRent = devRentMapper.selectLatestByPatCheckTypeStates(
                        createReqVO.getPatId(), createReqVO.getCheckType(), fallbackStateList);
                if (null == fallbackRent) {
                    throw exception(DEV_INSTALL_NOT_APPOINTMENT);
                }
                log.warn("[routineFinishOperation] 「待检查」单不存在，兜底复用最近一条已完成/已放弃单. "
                                + "rentId={} patId={} checkType={}",
                        fallbackRent.getId(), createReqVO.getPatId(), createReqVO.getCheckType());
                devRentDOList = new ArrayList<>(List.of(fallbackRent));
                jobRecordDO = jobRecordMapper.selectByRentIdDocId(fallbackRent.getId(), userId, jobTypeList);
                if (null != jobRecordDO) {
                    rent_id = fallbackRent.getId();
                    createReqVO.setId(rent_id);
                }
            }

            rent_id = devRentDOList.getFirst().getId();
            createReqVO.setId(rent_id);
            createReqVO.setState(DevRentStateEnum.ROUTINE_FINISH.getState());
            updateDevRent(createReqVO);
            if (null != jobRecordDO) {
                // 兜底命中已有完成记录 → 落到下方"更新"分支（与 else 分支同样的处理）
            } else {
                if (devRentDOList.size() != 1) {
                    throw exception(DEV_INSTALL_EXCEPTION);
                }

            JobRecordSaveReqVO jobRecordSaveReqVO = new JobRecordSaveReqVO();
            jobRecordSaveReqVO.setRentId(rent_id);
            jobRecordSaveReqVO.setDevId(createReqVO.getDevId());
            jobRecordSaveReqVO.setDocId(userId);
            jobRecordSaveReqVO.setDocName(userNickname);
            jobRecordSaveReqVO.setPatId(createReqVO.getPatId());
            jobRecordSaveReqVO.setPatName(createReqVO.getPatName());
            jobRecordSaveReqVO.setJobTime(createReqVO.getRentTime());
            jobRecordSaveReqVO.setJobType(DevRentStateEnum.ROUTINE_FINISH.getState());
            jobRecordSaveReqVO.setRemark(createReqVO.getRemark());
            jobRecordSaveReqVO.setSummary("");
            jobRecordSaveReqVO.setCheckType(createReqVO.getCheckType());
                rent_id = devRentDOList.get(0).getId();
                createReqVO.setId(rent_id);
                createReqVO.setState(DevRentStateEnum.ROUTINE_FINISH.getState());
                updateDevRent(createReqVO);

            JobRecordDO jobRecord = BeanUtils.toBean(jobRecordSaveReqVO, JobRecordDO.class);
            jobRecordMapper.insert(jobRecord);
        } else {
                JobRecordSaveReqVO jobRecordSaveReqVO = new JobRecordSaveReqVO();
                jobRecordSaveReqVO.setRentId(rent_id);
                jobRecordSaveReqVO.setDevId(createReqVO.getDevId());
                jobRecordSaveReqVO.setDocId(userId);
                jobRecordSaveReqVO.setDocName(userNickname);
                jobRecordSaveReqVO.setPatId(createReqVO.getPatId());
                jobRecordSaveReqVO.setPatName(createReqVO.getPatName());
                jobRecordSaveReqVO.setJobTime(createReqVO.getRentTime());
                jobRecordSaveReqVO.setJobType(DevRentStateEnum.ROUTINE_FINISH.getState());
                jobRecordSaveReqVO.setRemark(createReqVO.getRemark());
                jobRecordSaveReqVO.setSummary("");
                jobRecordSaveReqVO.setCheckType(createReqVO.getCheckType());

                JobRecordDO jobRecord = BeanUtils.toBean(jobRecordSaveReqVO, JobRecordDO.class);
                jobRecordMapper.insert(jobRecord);
            }
        }
        if (null != jobRecordDO) {
            // 撤销 放弃操作
            createReqVO.setId(rent_id);
            createReqVO.setState(DevRentStateEnum.ROUTINE_FINISH.getState());

            updateDevRent(createReqVO);
@@ -154,15 +195,63 @@
        //queueMapper.updateBedQueueStatus(createReqVO.getRoomId(), createReqVO.getBedNo(),
        //        QueueStatusEnum.ONSTAGE.getStatus(), QueueStatusEnum.FINISH.getStatus());

        QueueDO firstOnStageQueueItem = queueMapper.getBedFirstQueueItemByStatus(createReqVO.getRoomId(), createReqVO.getBedNo(), QueueStatusEnum.ONSTAGE.getStatus());
        // QueueStatusEnum.ONSTAGE  =>  QueueStatusEnum.FINISH
        firstOnStageQueueItem.setStatus(QueueStatusEnum.FINISH.getStatus());  // 默认状态 设置
        queueMapper.updateById(firstOnStageQueueItem);
        // 【缺陷修复】原实现：
        //   QueueDO firstOnStageQueueItem = queueMapper.getBedFirstQueueItemByStatus(
        //           roomId, bedNo, ONSTAGE);
        //   firstOnStageQueueItem.setStatus(FINISH);   // ← 取不到时为 null，直接 NPE
        //
        // 两个问题：
        //   1) NPE：该工位当前没有"就诊中(30)"患者时返回 null（例如医生先点了"放弃检查"，
        //      cancelRoutineOperation 已把该患者置为 40），第 159 行空指针 → 整个事务回滚。
        //   2) 误伤：只按"工位 + 状态取 seq_num 最小的一条"，若期间已叫了下一位患者，
        //      会把**下一位患者**误置为"已就诊(40)"。
        //
        // 修复策略（按可靠性从高到低）：
        //   ① 优先按 patId + checkType 精确匹配（前端 submitForm 传的 formData 含这两个字段）；
        //   ② 退化到"工位 + 状态 + 今日"取 update_time 最新的一条（比 seq_num 最小更贴合当前患者）；
        //   ③ 仍取不到 → 记警告并**跳过队列更新**，而不是抛 NPE 让整个"检查完成"失败。
        //      此时设备归还、作业记录等仍会正常保存（数据不丢），仅队列状态未变。
        QueueDO onStageQueueItem = null;

        // 检查项目.亲和性 处理逻辑
        CheckTypeDO checkTypeDO = queueServiceTxFunctions.getCheckTypeItem(firstOnStageQueueItem.getBookCheckType());
        if (checkTypeDO.getAffinityCheckTypes().length > 0) {
            procAffinityWhenRoutineFinish(firstOnStageQueueItem.getPatId(), checkTypeDO.getAffinityCheckTypes());
        // ① 精确定位（用 Spring 的 StringUtils，避免额外依赖；
        //    本模块未引入 commons-lang3，勿用 org.apache.commons.lang3.StringUtils）
        if (org.springframework.util.StringUtils.hasText(createReqVO.getPatId())
                && null != createReqVO.getCheckType()) {
            onStageQueueItem = queueMapper.getBedQueueItemByPatAndStatus(
                    createReqVO.getRoomId(), createReqVO.getBedNo(),
                    createReqVO.getPatId(), createReqVO.getCheckType(),
                    QueueStatusEnum.ONSTAGE.getStatus());
        }

        // ② 退化：取该工位今日最近更新的一条"就诊中"
        if (null == onStageQueueItem) {
            onStageQueueItem = queueMapper.getBedLatestQueueItemByStatus(
                    createReqVO.getRoomId(), createReqVO.getBedNo(), QueueStatusEnum.ONSTAGE.getStatus());
            if (null != onStageQueueItem) {
                log.warn("[routineFinish] 未按 patId 命中，退化为按工位取最近就诊中患者. "
                                + "roomId={} bedNo={} reqPatId={} reqCheckType={} 实际patId={} checkType={}",
                        createReqVO.getRoomId(), createReqVO.getBedNo(), createReqVO.getPatId(),
                        createReqVO.getCheckType(), onStageQueueItem.getPatId(),
                        onStageQueueItem.getBookCheckType());
            }
        }

        // ③ 仍取不到：跳过队列更新，不抛异常（保证"检查完成"本身可用）
        if (null == onStageQueueItem) {
            log.warn("[routineFinish] 该工位无[就诊中]患者，跳过队列状态更新. roomId={} bedNo={} patId={} applyNo={}",
                    createReqVO.getRoomId(), createReqVO.getBedNo(),
                    createReqVO.getPatId(), createReqVO.getApplyNo());
        } else {
            // QueueStatusEnum.ONSTAGE  =>  QueueStatusEnum.FINISH
            onStageQueueItem.setStatus(QueueStatusEnum.FINISH.getStatus());
            queueMapper.updateById(onStageQueueItem);

            // 检查项目.亲和性 处理逻辑
            CheckTypeDO checkTypeDO = queueServiceTxFunctions.getCheckTypeItem(onStageQueueItem.getBookCheckType());
            if (null != checkTypeDO && null != checkTypeDO.getAffinityCheckTypes()
                    && checkTypeDO.getAffinityCheckTypes().length > 0) {
                procAffinityWhenRoutineFinish(onStageQueueItem.getPatId(), checkTypeDO.getAffinityCheckTypes());
            }
        }

        //检查完成后，此时检查登记写成了，需要将这个回写给集成平台(线上环境才回写)
@@ -177,7 +266,13 @@
                log.info("routineFinishWebServiceClient的返回值为：{}", s);
                if (s.contains("更新成功")) {
                    //需要根据applyNo,将appiontment表里的status改成3
                    appointmentMapper.updateStatusByApplyNo(createReqVO.getApplyNo(), "3", new Date());
                    // 【诊断日志】同 AppointmentServiceImpl#handleAppointmentStatusUpdate：
                    // 打印日期对象类型与值，便于定位 register_date 被写成 00:00:00 的写入方。
                    java.util.Date regNow = new Date();
                    log.info("[devRentCreate][登记时间写入] applyNo={} 日期对象类型={} 值={}",
                            createReqVO.getApplyNo(), regNow.getClass().getName(),
                            new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(regNow));
                    appointmentMapper.updateStatusByApplyNo(createReqVO.getApplyNo(), "3", regNow);
                }
            } else {
                //检查类型是床边的或常规的，需要根据applyNo,将appiontment表里的status改成7
@@ -186,6 +281,106 @@
        }

        return CommonResult.success(rent_id);
    }

    /**
     * 【本需求：紧急患者不排队直接检查】为「紧急加做」的患者准备「待检查(0)」检查单。
     *
     * <h3>为什么需要它</h3>
     * 正常患者的 {@code dev_rent(state=0)} 行是**签到建队列**时一起插入的（见
     * {@code QueueServiceImpl#queue}）。紧急加做的患者不走签到/排队，所以完成时找不到这行，
     * 原逻辑会直接抛 {@code DEV_INSTALL_NOT_APPOINTMENT}（"请先预约确认"）。
     *
     * <h3>做法</h3>
     * <ol>
     *   <li>今天已有该患者 + 检查项目的「待检查」行 → 什么都不做（走正常流程）；</li>
     *   <li>否则按**预约单**（申请单号优先，其次患者编号 + 检查项目，近 ±30 天）补建一行；</li>
     *   <li>同时把备注补上「紧急加做」，便于在完成列表/报表里区分。</li>
     * </ol>
     * 预约单不存在或检查项目不匹配时**不补建**，让原逻辑照常报错，避免产生脏数据。
     */
    private void prepareEmergencyDevRent(RoutineFinishReqVO req, DevRentSaveReqVO createReqVO) {
        // 备注统一打标（原备注保留）
        String remark = createReqVO.getRemark();
        if (org.springframework.util.StringUtils.hasText(remark)) {
            if (!remark.contains(EMERGENCY_REMARK)) {
                createReqVO.setRemark(EMERGENCY_REMARK + "；" + remark);
            }
        } else {
            createReqVO.setRemark(EMERGENCY_REMARK);
        }

        if (org.springframework.util.StringUtils.hasText(req.getPatId()) && null != req.getCheckType()) {
            List<DevRentDO> existList = devRentMapper.selectByPatAndChecktypeAndState(
                    req.getPatId(), req.getCheckType(), DevRentStateEnum.FREE.getState());
            if (!existList.isEmpty()) {
                log.info("[prepareEmergencyDevRent] 今日已有待检查单，按正常流程完成. patId={} checkType={} 条数={}",
                        req.getPatId(), req.getCheckType(), existList.size());
                return;
            }
        }

        AppointmentDO appointment = findEmergencyAppointment(req);
        if (null == appointment) {
            log.warn("[prepareEmergencyDevRent] 未找到可用的预约单，跳过补建（原逻辑将报「请先预约确认」）. "
                    + "applyNo={} patId={} checkType={}", req.getApplyNo(), req.getPatId(), req.getCheckType());
            return;
        }

        DevRentDO devRent = new DevRentDO();
        devRent.setApplyNo(nonBlank(appointment.getApplyNo(), req.getApplyNo()));
        devRent.setEpisodeId(nonBlank(appointment.getEpisodeId(), req.getEpisodeId()));
        devRent.setPatId(nonBlank(appointment.getPatId(), req.getPatId()));
        devRent.setPatName(nonBlank(appointment.getPatName(), req.getPatName()));
        devRent.setCheckType(appointment.getBookCheckType());
        devRent.setPaid(appointment.getPaid());
        devRent.setState(DevRentStateEnum.FREE.getState());
        devRent.setRemark(createReqVO.getRemark());
        devRentMapper.insert(devRent);

        // 让后续「按患者 + 检查项目 + 今日 + 待检查」能正常定位到
        createReqVO.setId(devRent.getId());
        createReqVO.setApplyNo(devRent.getApplyNo());
        createReqVO.setEpisodeId(devRent.getEpisodeId());
        // 检查项目以预约单为准；预约单没写时才沿用请求里的值（避免把 checkType 置空导致后续报错）
        if (null != devRent.getCheckType()) {
            createReqVO.setCheckType(devRent.getCheckType());
        }
        if (null == createReqVO.getPaid()) {
            createReqVO.setPaid(devRent.getPaid());
        }
        log.info("[prepareEmergencyDevRent] 紧急加做：已补建「待检查」检查单. rentId={} patId={} checkType={} applyNo={}",
                devRent.getId(), devRent.getPatId(), devRent.getCheckType(), devRent.getApplyNo());
    }

    /** 紧急加做：定位要用哪张预约单（申请单号优先，其次患者编号 + 检查项目，近 ±30 天，取最近的） */
    private AppointmentDO findEmergencyAppointment(RoutineFinishReqVO req) {
        // ① 申请单号能直接命中
        if (org.springframework.util.StringUtils.hasText(req.getApplyNo())) {
            AppointmentDO byApplyNo = appointmentMapper.getByApplyNo(req.getApplyNo());
            if (null != byApplyNo && matchesCheckType(byApplyNo, req.getCheckType())) {
                return byApplyNo;
            }
        }
        // ② 按患者编号 + 检查项目，取最近一张
        if (org.springframework.util.StringUtils.hasText(req.getPatId()) && null != req.getCheckType()) {
            List<Integer> one = new ArrayList<>();
            one.add(req.getCheckType());
            List<AppointmentDO> candidates = appointmentMapper.getEmergencyCandidates(req.getPatId(), one);
            if (!candidates.isEmpty()) {
                return candidates.get(0);
            }
        }
        return null;
    }

    private boolean matchesCheckType(AppointmentDO appointment, Integer checkType) {
        return null == checkType || null == appointment.getBookCheckType()
                || checkType.equals(appointment.getBookCheckType());
    }

    private String nonBlank(String first, String second) {
        return org.springframework.util.StringUtils.hasText(first) ? first : second;
    }

    /**
@@ -220,7 +415,12 @@
            log.info("webservice的返回值为：{}", s);
            if (s.contains("更新成功")) {
                //需要根据applyNo,将appiontment表里的status改成3
                appointmentMapper.updateStatusByApplyNo(createReqVO.getApplyNo(), "3", new Date());
                // 【诊断日志】同上：打印日期对象类型与值
                java.util.Date regNow2 = new Date();
                log.info("[devRentOther][登记时间写入] applyNo={} 日期对象类型={} 值={}",
                        createReqVO.getApplyNo(), regNow2.getClass().getName(),
                        new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(regNow2));
                appointmentMapper.updateStatusByApplyNo(createReqVO.getApplyNo(), "3", regNow2);
            }
        }
        List<Integer> jobTypeList = new ArrayList<Integer>();
@@ -234,7 +434,7 @@
                throw exception(DEV_INSTALL_EXCEPTION);
            }

            rent_id = devRentDOList.getFirst().getId();
            rent_id = devRentDOList.get(0).getId();
            createReqVO.setId(rent_id);
            createReqVO.setState(DevRentStateEnum.RECEIVED.getState());
            updateDevRent(createReqVO);
@@ -322,7 +522,7 @@
                throw exception(DEV_INSTALL_EXCEPTION);
            }

            rent_id = devRentDOList.getFirst().getId();
            rent_id = devRentDOList.get(0).getId();
            createReqVO.setId(rent_id);
            createReqVO.setState(DevRentStateEnum.INSTALLED.getState());
            updateDevRent(createReqVO);
@@ -476,7 +676,7 @@
            List<DevRentDO> devRentDOList = devRentMapper.selectByPatAndChecktypeAndState(createReqVO.getPatId(), createReqVO.getCheckType(), DevRentStateEnum.FREE.getState());
            if (devRentDOList.size() != 1) throw exception(ROUTINE_CHECK_EXIST);

            rent_id = devRentDOList.getFirst().getId();
            rent_id = devRentDOList.get(0).getId();
            createReqVO.setId(rent_id);
            createReqVO.setState(DevRentStateEnum.ROUTINE_CANCELLED.getState());
            updateDevRent(createReqVO);
@@ -560,7 +760,7 @@
            List<DevRentDO> devRentDOList = devRentMapper.selectByPatAndChecktypeAndState(createReqVO.getPatId(), createReqVO.getCheckType(), DevRentStateEnum.FREE.getState());
            if (devRentDOList.size() != 1) throw exception(DEV_INSTALL_EXIST);

            rent_id = devRentDOList.getFirst().getId();
            rent_id = devRentDOList.get(0).getId();
            createReqVO.setId(rent_id);
            createReqVO.setState(DevRentStateEnum.RECEIVED_CANCELLED.getState());
            updateDevRent(createReqVO);
@@ -635,7 +835,7 @@
            List<DevRentDO> devRentDOList = devRentMapper.selectByPatAndChecktypeAndState(createReqVO.getPatId(), createReqVO.getCheckType(), DevRentStateEnum.RECEIVED.getState());
            if (devRentDOList.size() != 1) throw exception(DEV_INSTALL_EXIST);

            rent_id = devRentDOList.getFirst().getId();
            rent_id = devRentDOList.get(0).getId();
            createReqVO.setId(rent_id);
            createReqVO.setState(DevRentStateEnum.INSTALL_CANCELLED.getState());
            updateDevRent(createReqVO);
@@ -771,13 +971,17 @@

    @Override
    public DevRentDO getDevRent(Long id) {
        return devRentMapper.selectById(id);
        DevRentDO devRentDO = devRentMapper.selectById(id);
        fillPatientInfo(devRentDO);
        return devRentDO;
    }

    @Override
    public PageResult<DevRentDO> getDevRentPage(DevRentPageReqVO pageReqVO) {
        pageReqVO.setState(0);
        return devRentMapper.selectPage(pageReqVO);
        PageResult<DevRentDO> pageResult = devRentMapper.selectPage(pageReqVO);
        fillPatientInfo(pageResult.getList());
        return pageResult;
    }

    @Override
@@ -786,15 +990,65 @@
        stateList.add(DevRentStateEnum.INSTALLED.getState());
        stateList.add(DevRentStateEnum.RECEIVED.getState());
        searchReqVO.setStateList(stateList);
        return devRentMapper.getRentByState(searchReqVO);
        DevRentDO devRentDO = devRentMapper.getRentByState(searchReqVO);
        fillPatientInfo(devRentDO);
        return devRentDO;
    }

    /**
     * 撤销「检查完成」后的回滚：检查单 60(常规检查完成) → 0(待检查)，并取消确费。
     *
     * <p>【本次修复的根因】撤销原先只把队列行 40→20，`dev_rent` 仍是 60：
     * 前端再次完成时 `getFreeRent`（只查 state=0）取不到单 → `formData.id` 为空
     * → 后端 `routineFinishOperation` 按 (patId, checkType, state=0) 也找不到 → 报「请先预约确认」。
     * 把状态回滚到 0 后，整条链路恢复正常。
     *
     * <p>失败策略：全程 try/catch，回滚/取消费失败都只记日志，**不影响"撤销"本身的结果**。
     */
    @Override
    public void rollbackRoutineFinish(String patId, Integer checkType) {
        try {
            List<Integer> finishedStateList = new ArrayList<>();
            finishedStateList.add(DevRentStateEnum.ROUTINE_FINISH.getState());
            DevRentDO rent = devRentMapper.selectLatestByPatCheckTypeStates(patId, checkType, finishedStateList);
            if (null == rent) {
                log.warn("[rollbackRoutineFinish] 未找到今日该患者的「常规检查完成」检查单，跳过回滚. patId={} checkType={}",
                        patId, checkType);
                return;
            }

            // ① 状态回滚（只改 state，rent_time/return_time 保留，作为"做过一次"的痕迹）
            DevRentDO updateObj = new DevRentDO();
            updateObj.setId(rent.getId());
            updateObj.setState(DevRentStateEnum.FREE.getState());
            devRentMapper.updateById(updateObj);
            log.info("[rollbackRoutineFinish] 检查单已回滚为[待检查]. rentId={} patId={} checkType={}",
                    rent.getId(), patId, checkType);

            // ② 取消确费（第一次完成时控制器会自动确费；撤销后应回退，再次完成时重新确费）
            Integer paid = rent.getPaid();
            if (null != paid && 1 == paid) {
                try {
                    String hisId = SecurityFrameworkUtils.getLoginUserHisId();
                    String nickname = SecurityFrameworkUtils.getLoginUserNickname();
                    Integer ret = feeConfirm(rent.getId(), hisId, nickname, false);
                    log.info("[rollbackRoutineFinish] 已取消确费. rentId={} 返回={}", rent.getId(), ret);
                } catch (Exception e) {
                    log.error("[rollbackRoutineFinish] 取消确费失败（不影响撤销）. rentId={}", rent.getId(), e);
                }
            }
        } catch (Exception e) {
            log.error("[rollbackRoutineFinish] 回滚检查单失败（不影响撤销）. patId={} checkType={}", patId, checkType, e);
        }
    }

    @Override
    public DevRentDO getFreeRent(DevRentSearchReqVO searchReqVO) {
        List<Integer> stateList = new ArrayList<>();
    public DevRentDO getFreeRent(DevRentSearchReqVO searchReqVO) {        List<Integer> stateList = new ArrayList<>();
        stateList.add(DevRentStateEnum.FREE.getState());
        searchReqVO.setStateList(stateList);
        return devRentMapper.getRentByState(searchReqVO);
        DevRentDO devRentDO = devRentMapper.getRentByState(searchReqVO);
        fillPatientInfo(devRentDO);
        return devRentDO;
    }

    @Override
@@ -803,7 +1057,9 @@
        stateList.add(DevRentStateEnum.RECEIVED.getState());
        stateList.add(DevRentStateEnum.RECEIVED_CANCELLED.getState());
        searchReqVO.setStateList(stateList);
        return devRentMapper.getRentByState(searchReqVO);
        DevRentDO devRentDO = devRentMapper.getRentByState(searchReqVO);
        fillPatientInfo(devRentDO);
        return devRentDO;
    }

    @Override
@@ -811,7 +1067,67 @@
        List<Integer> stateList = new ArrayList<>();
        stateList.add(DevRentStateEnum.DISMANTLED.getState());
        searchReqVO.setStateList(stateList);
        return devRentMapper.getRentByState(searchReqVO);
        DevRentDO devRentDO = devRentMapper.getRentByState(searchReqVO);
        fillPatientInfo(devRentDO);
        return devRentDO;
    }

    // ==================== 需求1：回填患者信息 18 项 ====================
    // dev_rent 表只存了 applyNo / patName / patDetails，
    // 其余患者信息（性别、出生日期、病区、床号、电话、来源、就诊卡号、
    // 登记时间、开单医师、开单日期、多耐药）都在 appointment 表。
    //
    // 参照 QueueServiceImpl#fillAppointmentInfo 的做法：查询后按 applyNo 回查预约单补齐。
    // 这样领用/装机/拆机/数据录入/检查记录 5 个界面才能展示完整患者信息。

    /**
     * 回填单个对象的患者信息（对象为 null 或 applyNo 为空时安全跳过）。
     */
    private void fillPatientInfo(DevRentDO devRentDO) {
        if (null == devRentDO || !org.springframework.util.StringUtils.hasText(devRentDO.getApplyNo())) {
            return;
        }
        AppointmentDO appointment = appointmentMapper.getByApplyNo(devRentDO.getApplyNo());
        if (null == appointment) {
            return;
        }
        applyAppointmentToDevRent(devRentDO, appointment);
    }

    /**
     * 批量回填（避免 N+1 之外的额外开销由调用方控制；此处逐条回查，
     * 与 QueueServiceImpl#fillAppointmentInfo 保持一致的做法）。
     */
    private void fillPatientInfo(List<DevRentDO> devRentDOList) {
        if (null == devRentDOList || devRentDOList.isEmpty()) {
            return;
        }
        devRentDOList.forEach(this::fillPatientInfo);
    }

    /**
     * 把预约单中的患者信息复制到 dev_rent 对象。
     * <p>
     * 注意：只覆盖**为空的**平铺字段？——不，这里直接覆盖：
     * 这些字段均标记为 {@code @TableField(exist=false)}，不参与写库，
     * 本次查询返回的就是最新数据，不存在"覆盖掉用户刚录入的值"的风险。
     */
    private void applyAppointmentToDevRent(DevRentDO target, AppointmentDO source) {
        target.setPatGender(source.getPatGender());
        target.setPatBirthday(source.getPatBirthday());
        target.setRegisterDate(source.getRegisterDate());
        target.setDoctor(source.getDoctor());
        target.setDoctorTime(source.getDoctorTime());
        target.setPatSrc(source.getPatSrc());
        target.setPatMobile(source.getPatMobile());
        target.setPatPhone(source.getPatPhone());
        target.setPatWardDesc(source.getPatWardDesc());
        target.setPatBedNo(source.getPatBedNo());
        target.setMedicalCard(source.getMedicalCard());
        if (target.getDoctorAdviceNo() == null) target.setDoctorAdviceNo(source.getDoctorAdviceNo());
        target.setOutpatientNo(source.getOutpatientNo());
        target.setPatIdentityId(source.getPatIdentityId());
        target.setTolerance(source.getTolerance());
    }

    // 确费处理