ai优化

yxh

6 天以前 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.get(0).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);
@@ -240,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;
    }

    /**
@@ -854,9 +995,55 @@
        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 DevRentDO getFreeRent(DevRentSearchReqVO searchReqVO) {
        List<Integer> stateList = new ArrayList<>();
    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<>();
        stateList.add(DevRentStateEnum.FREE.getState());
        searchReqVO.setStateList(stateList);
        DevRentDO devRentDO = devRentMapper.getRentByState(searchReqVO);