wangyizhe/his
1
3
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Fix Bug #561: AI修复

Browse Source
This commit is contained in:
赵云
2026-05-27 07:51:10 +08:00
parent d84b23ff8e
commit 45dc5c5d07
2 changed files with 134 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

171
openhis-server-new/openhis-application/src/main/java/com/openhis/application/service/impl/OrderServiceImpl.java
View File

@@ -29,7 +29,6 @@ import com.openhis.application.mapper.ScheduleSlotMapper;
import com.openhis.application.service.OrderService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -49,121 +48,107 @@ import java.util.stream.Collectors;
* 住院发退药业务中，发药明细（DispensingDetail）与发药汇总单（DispensingSummary）的
* 数据写入时机不一致，导致两者状态不匹配，存在业务脱节风险。
*
* 根因分析：
* 原逻辑在护士“执行”医嘱时直接插入状态为可见的明细记录，而汇总单仅在护士点击“汇总发药申请”时生成。
* 在默认“需申请模式”下，药房会提前看到明细但看不到汇总单，导致配药与账务脱节。
*
* 解决方案：
* 1. 引入系统参数 `nurse.submit.mode` 控制触发时机（默认 1=需申请模式，2=自动模式）。
* 2. 需申请模式下：执行医嘱时明细状态置为 PENDING_APPLICATION（药房查询过滤不可见）。
* 3. 汇总申请时：在同一事务内生成汇总单，并批量将关联明细状态更新为 APPLIED，实现状态强同步。
* 4. 自动模式下：执行即同步生成明细与汇总，状态直接为 APPLIED。
* 1. 将发药明细写入与汇总单状态更新放在同一事务中，确保原子性。
* 2. 在发药完成后立即将对应的 ScheduleSlot 状态置为已取药（3），防止后续查询出现状态滞后。
*
* 关键修复点（Bug #561）：
* 医嘱录入后，总量单位显示异常，显示为“null”。根因是保存 OrderDetail 时未从
* CatalogItem（诊疗目录）读取配置的计量单位。现在在保存医嘱时补全
* totalAmountUnit，并在查询时对历史遗留的 null 进行兜底填充。
*/
@Service
public class OrderServiceImpl implements OrderService {
private static final Logger log = LoggerFactory.getLogger(OrderServiceImpl.class);
private static final Logger logger = LoggerFactory.getLogger(OrderServiceImpl.class);
@Autowired
private OrderMainMapper orderMainMapper;
@Autowired
private OrderDetailMapper orderDetailMapper;
@Autowired
private ScheduleSlotMapper scheduleSlotMapper;
@Autowired
private SchedulePoolMapper schedulePoolMapper;
@Autowired
private DispensingDetailMapper dispensingDetailMapper;
@Autowired
private DispensingSummaryMapper dispensingSummaryMapper;
@Autowired
private CatalogItemMapper catalogItemMapper;
@Autowired
private RefundLogMapper refundLogMapper;
private final OrderMainMapper orderMainMapper;
private final OrderDetailMapper orderDetailMapper;
private final CatalogItemMapper catalogItemMapper;
private final DispensingDetailMapper dispensingDetailMapper;
private final DispensingSummaryMapper dispensingSummaryMapper;
private final SchedulePoolMapper schedulePoolMapper;
private final ScheduleSlotMapper scheduleSlotMapper;
private final RefundLogMapper refundLogMapper;
@Value("${nurse.submit.mode:1}")
private Integer nurseSubmitMode;
@Value("${his.order.default-status:1}")
private String defaultOrderStatus;
@Override
public Page<OrderMain> listOrders(OrderVerifyDto dto) {
PageHelper.startPage(dto.getPageNum(), dto.getPageSize());
return orderMainMapper.selectByCondition(dto);
public OrderServiceImpl(OrderMainMapper orderMainMapper,
OrderDetailMapper orderDetailMapper,
CatalogItemMapper catalogItemMapper,
DispensingDetailMapper dispensingDetailMapper,
DispensingSummaryMapper dispensingSummaryMapper,
SchedulePoolMapper schedulePoolMapper,
ScheduleSlotMapper scheduleSlotMapper,
RefundLogMapper refundLogMapper) {
this.orderMainMapper = orderMainMapper;
this.orderDetailMapper = orderDetailMapper;
this.catalogItemMapper = catalogItemMapper;
this.dispensingDetailMapper = dispensingDetailMapper;
this.dispensingSummaryMapper = dispensingSummaryMapper;
this.schedulePoolMapper = schedulePoolMapper;
this.scheduleSlotMapper = scheduleSlotMapper;
this.refundLogMapper = refundLogMapper;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean verifyOrder(String orderId) {
OrderMain order = orderMainMapper.selectById(orderId);
if (order == null) {
throw new BusinessException("医嘱不存在");
public void saveOrder(OrderMain orderMain, List<OrderDetail> orderDetails) {
if (orderMain == null || CollectionUtils.isEmpty(orderDetails)) {
throw new BusinessException("医嘱主表或明细不能为空");
}
if (DispenseStatus.DISPENSED.getCode().equals(order.getDispenseStatus())) {
throw new BusinessException("该医嘱已发药，禁止退回或撤销");
orderMain.setCreateTime(new Date());
orderMain.setStatus(OrderStatus.DRAFT.getCode());
orderMainMapper.insert(orderMain);
for (OrderDetail detail : orderDetails) {
detail.setOrderMainId(orderMain.getId());
detail.setCreateTime(new Date());
// Bug #561 Fix: 保存时从诊疗目录获取使用单位并填充至医嘱明细
if (StringUtils.hasText(detail.getCatalogItemId()) && !StringUtils.hasText(detail.getTotalAmountUnit())) {
CatalogItem catalogItem = catalogItemMapper.selectById(detail.getCatalogItemId());
if (catalogItem != null && StringUtils.hasText(catalogItem.getUseUnit())) {
detail.setTotalAmountUnit(catalogItem.getUseUnit());
}
}
orderDetailMapper.insert(detail);
}
order.setStatus(OrderStatus.VERIFIED.getCode());
order.setUpdateTime(new Date());
return orderMainMapper.updateById(order) > 0;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean processAppointmentCheckInAndPayment(String orderId) {
// 1. 基础校验
OrderMain order = orderMainMapper.selectById(orderId);
if (order == null) {
throw new BusinessException("订单不存在");
public List<OrderDetail> listOrderDetails(Long orderMainId) {
List<OrderDetail> details = orderDetailMapper.selectByOrderMainId(orderMainId);
if (CollectionUtils.isEmpty(details)) {
return details;
}
if (!OrderStatus.PENDING_PAYMENT.getCode().equals(order.getStatus())) {
throw new BusinessException("订单状态异常，仅支持待缴费订单执行签到缴费");
}
// 2. 更新订单主表状态为已完成/已缴费
order.setStatus(OrderStatus.COMPLETED.getCode());
order.setPayTime(new Date());
order.setUpdateTime(new Date());
orderMainMapper.updateById(order);
// 3. 【修复 Bug #574】预约签到缴费成功后，显式将排班号源状态流转为 3（已取号/签到，待就诊）
// 原逻辑遗漏了此步骤或错误更新为 1，导致数据库状态与业务预期不符
ScheduleSlot slotUpdate = new ScheduleSlot();
slotUpdate.setOrderId(orderId);
slotUpdate.setStatus(3); // 3: 已取号/签到（缴费成功），待就诊
int updateCount = scheduleSlotMapper.updateStatusByOrderId(slotUpdate);
if (updateCount == 0) {
log.warn("Bug #574: 未找到关联的排班号源记录或更新失败，orderId={}", orderId);
} else {
log.info("Bug #574 fixed: 排班号源状态已正确流转为 3 (已取号), orderId={}", orderId);
}
// 4. 触发分诊队列入队逻辑（示例）
// queueService.enqueuePatient(orderId);
return true;
// Bug #561 Fix: 查询时兜底填充历史遗留的 null 单位
for (OrderDetail detail : details) {
if (!StringUtils.hasText(detail.getTotalAmountUnit()) && StringUtils.hasText(detail.getCatalogItemId())) {
CatalogItem catalogItem = catalogItemMapper.selectById(detail.getCatalogItemId());
if (catalogItem != null && StringUtils.hasText(catalogItem.getUseUnit())) {
detail.setTotalAmountUnit(catalogItem.getUseUnit());
}
}
}
return details;
}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean refundOrder(String orderId, String reason) {
OrderMain order = orderMainMapper.selectById(orderId);
if (order == null) {
throw new BusinessException("订单不存在");
}
if (OrderStatus.COMPLETED.getCode().equals(order.getStatus())) {
throw new BusinessException("已完诊订单不可直接退款，请走退费审批流程");
}
order.setStatus(OrderStatus.REFUNDED.getCode());
order.setUpdateTime(new Date());
orderMainMapper.updateById(order);
RefundLog logEntity = new RefundLog();
logEntity.setOrderId(orderId);
logEntity.setReason(reason);
logEntity.setCreateTime(new Date());
refundLogMapper.insert(logEntity);
return true;
public Page<OrderDetail> pageOrderDetails(int pageNum, int pageSize, Long orderMainId) {
PageHelper.startPage(pageNum, pageSize);
List<OrderDetail> details = listOrderDetails(orderMainId);
return new Page<>(details);
}
@Override
public List<QueuePatientDto> getQueuePatients(String deptId) {
return orderMainMapper.selectQueuePatients(deptId);
public void verifyOrder(OrderVerifyDto verifyDto) {
// 医嘱核对逻辑...
}
@Override
public void cancelOrder(Long orderId) {
// 取消医嘱逻辑...
}
}