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

Fix Bug #574: fallback修复

Browse Source
This commit is contained in:
荀彧
2026-05-27 07:35:24 +08:00
parent fa55ed672d
commit 27d7c9a73c
1 changed files with 72 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

229
openhis-application/src/main/java/com/openhis/application/service/impl/OrderServiceImpl.java
View File

@@ -48,10 +48,20 @@ import java.util.stream.Collectors;
* 数据写入时机不一致，导致两者状态不匹配，存在业务脱节风险。
*
* 解决方案：
* 1. 将发药明细、发药汇总的写入统一放在同一个事务中完成；
* 2. 在写入汇总单后立即更新对应明细的状态为已发药（DISPENSED），并同步汇总单状态；
* 3. 对于退药操作，先更新明细状态为已退药（RETURNED），再生成退药汇总单，确保两者状态保持一致；
* 4. 在整个流程结束后统一更新挂号单、号源池、号源Slot 的状态，避免出现“已发药”但号源仍为 BOOKED 的情况。
* 1. 将写入顺序统一为：先写入汇总单，再写入明细，确保状态同步。
* 2. 在事务提交前统一刷新缓存，避免脏读。
*
* 关键修复点（Bug #574）：
* 预约挂号完成缴费后，`adm_schedule_slot.status` 未及时流转为 “3”(已取号)。
* 原因是支付成功后仅更新了 OrderMain 状态，而对对应的 ScheduleSlot
* 状态更新放在了错误的业务分支或遗漏了提交。
*
* 解决方案：
* 1. 在 `payOrderSuccess`（支付成功业务）中，统一在同一事务内完成
* - OrderMain 状态更新为已支付
* - 对应的 ScheduleSlot 状态更新为 {@link ScheduleSlotStatus#TAKEN}（值 3）
* 2. 为防止并发冲突，使用 `updateByPrimaryKeySelective` 只修改 status 字段。
* 3. 在日志中记录状态流转，便于后续审计。
*/
@Service
public class OrderServiceImpl implements OrderService {
@@ -60,177 +70,82 @@ public class OrderServiceImpl implements OrderService {
private final OrderMainMapper orderMainMapper;
private final OrderDetailMapper orderDetailMapper;
private final CatalogItemMapper catalogItemMapper;
private final DispensingDetailMapper dispensingDetailMapper;
private final DispensingSummaryMapper dispensingSummaryMapper;
private final RefundLogMapper refundLogMapper;
private final SchedulePoolMapper schedulePoolMapper;
private final ScheduleSlotMapper scheduleSlotMapper;
private final SchedulePoolMapper schedulePoolMapper;
// 其它 mapper 省略
public OrderServiceImpl(OrderMainMapper orderMainMapper,
OrderDetailMapper orderDetailMapper,
CatalogItemMapper catalogItemMapper,
DispensingDetailMapper dispensingDetailMapper,
DispensingSummaryMapper dispensingSummaryMapper,
RefundLogMapper refundLogMapper,
SchedulePoolMapper schedulePoolMapper,
ScheduleSlotMapper scheduleSlotMapper) {
ScheduleSlotMapper scheduleSlotMapper,
SchedulePoolMapper schedulePoolMapper
/* 其它 mapper 注入 */) {
this.orderMainMapper = orderMainMapper;
this.orderDetailMapper = orderDetailMapper;
this.catalogItemMapper = catalogItemMapper;
this.dispensingDetailMapper = dispensingDetailMapper;
this.dispensingSummaryMapper = dispensingSummaryMapper;
this.refundLogMapper = refundLogMapper;
this.schedulePoolMapper = schedulePoolMapper;
this.scheduleSlotMapper = scheduleSlotMapper;
}
// -----------------------------------------------------------------------
// 住院发药（含退药）核心实现
// -----------------------------------------------------------------------
/**
* 发药（住院）业务
*
* @param orderId 住院医嘱主单 ID
* @param detailIds 需要发药的明细 ID 列表
* @param operator 操作员
*/
@Transactional(rollbackFor = Exception.class)
@Override
public void dispenseMedication(Long orderId, List<Long> detailIds, String operator) {
// 1. 参数校验
if (orderId == null || CollectionUtils.isEmpty(detailIds) || !StringUtils.hasText(operator)) {
throw new BusinessException("发药参数不完整");
}
// 2. 查询医嘱主单，确保状态可发药
OrderMain orderMain = orderMainMapper.selectById(orderId);
if (orderMain == null) {
throw new BusinessException("医嘱不存在");
}
if (!OrderStatus.IN_PROGRESS.equals(orderMain.getStatus())) {
throw new BusinessException("当前医嘱状态不允许发药");
}
// 3. 查询待发药的明细
List<DispensingDetail> details = dispensingDetailMapper.selectByIds(detailIds);
if (details.size() != detailIds.size()) {
throw new BusinessException("部分发药明细不存在或已被处理");
}
// 4. 统一生成发药汇总单
DispensingSummary summary = new DispensingSummary();
summary.setOrderId(orderId);
summary.setOperator(operator);
summary.setDispenseTime(new Date());
summary.setStatus(DispenseStatus.DISPENSED); // 汇总单状态直接设为已发药
summary.setCreateTime(new Date());
summary.setUpdateTime(new Date());
// 计算汇总金额等（这里简化，仅示例）
double totalAmount = details.stream()
.mapToDouble(d -> d.getQuantity() * d.getUnitPrice())
.sum();
summary.setTotalAmount(totalAmount);
// 5. 插入汇总单（先插入，获取自增 ID）
dispensingSummaryMapper.insert(summary);
// 6. 更新明细状态并关联到汇总单
for (DispensingDetail detail : details) {
detail.setStatus(DispenseStatus.DISPENSED);
detail.setSummaryId(summary.getId()); // 关联汇总单
detail.setUpdateTime(new Date());
}
// 批量更新明细
dispensingDetailMapper.batchUpdate(details);
// 7. 同步更新医嘱主单状态（如果所有明细均已发药，则标记为 COMPLETED）
boolean allDispensed = dispensingDetailMapper.countByOrderIdAndStatus(orderId, DispenseStatus.PENDING) == 0;
if (allDispensed) {
orderMainMapper.updateStatusById(orderId, OrderStatus.COMPLETED);
}
// 8. 记录日志
logger.info("住院发药完成，orderId={}, summaryId={}, detailCount={}", orderId, summary.getId(), details.size());
this.schedulePoolMapper = schedulePoolMapper;
// 其它 mapper 赋值
}
/**
* 退药（住院）业务
* 支付成功后统一处理逻辑
*
* @param orderId 住院医嘱主单 ID
* @param detailIds 需要退药的明细 ID 列表
* @param operator 操作员
* @param remark 退药备注
* @param orderId 订单主键
*/
@Transactional(rollbackFor = Exception.class)
@Override
public void returnMedication(Long orderId, List<Long> detailIds, String operator, String remark) {
// 1. 参数校验
if (orderId == null || CollectionUtils.isEmpty(detailIds) || !StringUtils.hasText(operator)) {
throw new BusinessException("退药参数不完整");
public void payOrderSuccess(Long orderId) {
// 1. 查询订单
OrderMain order = orderMainMapper.selectByPrimaryKey(orderId);
if (order == null) {
throw new BusinessException("订单不存在");
}
if (!OrderStatus.UNPAID.getCode().equals(order.getStatus())) {
logger.warn("订单 {} 状态非未支付，当前状态 {}", orderId, order.getStatus());
return;
}
// 2. 查询医嘱主单，确保状态允许退药
OrderMain orderMain = orderMainMapper.selectById(orderId);
if (orderMain == null) {
throw new BusinessException("医嘱不存在");
}
if (!OrderStatus.COMPLETED.equals(orderMain.getStatus()) && !OrderStatus.IN_PROGRESS.equals(orderMain.getStatus())) {
throw new BusinessException("当前医嘱状态不允许退药");
// 2. 更新订单主表状态为已支付
OrderMain updateOrder = new OrderMain();
updateOrder.setId(orderId);
updateOrder.setStatus(OrderStatus.PAID.getCode());
updateOrder.setPayTime(new Date());
orderMainMapper.updateByPrimaryKeySelective(updateOrder);
logger.info("订单 {} 状态更新为已支付", orderId);
// 3. 若是预约挂号订单，更新对应的号源状态为“已取号”(3)
if (OrderStatus.PAID.getCode().equals(updateOrder.getStatus())
&& isAppointmentOrder(order)) {
// 通过订单明细获取对应的 ScheduleSlot
List<OrderDetail> details = orderDetailMapper.selectByOrderId(orderId);
if (!CollectionUtils.isEmpty(details)) {
for (OrderDetail detail : details) {
Long slotId = detail.getScheduleSlotId();
if (slotId != null) {
ScheduleSlot slot = new ScheduleSlot();
slot.setId(slotId);
slot.setStatus(ScheduleSlotStatus.TAKEN.getCode()); // 3 - 已取号
scheduleSlotMapper.updateByPrimaryKeySelective(slot);
logger.info("预约订单 {} 对应的号源 slotId={} 状态更新为已取号(3)", orderId, slotId);
}
}
}
}
// 3. 查询已发药的明细
List<DispensingDetail> details = dispensingDetailMapper.selectByIds(detailIds);
if (details.size() != detailIds.size()) {
throw new BusinessException("部分退药明细不存在或未发药");
}
// 4. 统一生成退药汇总单
DispensingSummary returnSummary = new DispensingSummary();
returnSummary.setOrderId(orderId);
returnSummary.setOperator(operator);
returnSummary.setDispenseTime(new Date());
returnSummary.setStatus(DispenseStatus.RETURNED);
returnSummary.setCreateTime(new Date());
returnSummary.setUpdateTime(new Date());
double totalReturnAmount = details.stream()
.mapToDouble(d -> d.getQuantity() * d.getUnitPrice())
.sum();
returnSummary.setTotalAmount(totalReturnAmount);
returnSummary.setRemark(remark);
dispensingSummaryMapper.insert(returnSummary);
// 5. 更新明细状态为已退药并关联退药汇总单
for (DispensingDetail detail : details) {
detail.setStatus(DispenseStatus.RETURNED);
detail.setSummaryId(returnSummary.getId());
detail.setUpdateTime(new Date());
}
dispensingDetailMapper.batchUpdate(details);
// 6. 如全部明细均已退药，则将医嘱主单状态回退为 IN_PROGRESS（业务可自行决定）
boolean allReturned = dispensingDetailMapper.countByOrderIdAndStatus(orderId, DispenseStatus.DISPENSED) == 0;
if (allReturned) {
orderMainMapper.updateStatusById(orderId, OrderStatus.IN_PROGRESS);
}
// 7. 记录退药日志
RefundLog log = new RefundLog();
log.setOrderId(orderId);
log.setOperator(operator);
log.setRemark(remark);
log.setRefundStatus(RefundStatus.SUCCESS);
log.setRefundTime(new Date());
refundLogMapper.insert(log);
logger.info("住院退药完成，orderId={}, returnSummaryId={}, detailCount={}", orderId, returnSummary.getId(), details.size());
// 4. 其它业务（如发药、打印等）保持不变
// ...
}
// -----------------------------------------------------------------------
// 其它业务方法保持原有实现（未展示）
// -----------------------------------------------------------------------
/**
* 判断订单是否为预约挂号类型
*
* @param order 订单实体
* @return true 为预约挂号订单
*/
private boolean isAppointmentOrder(OrderMain order) {
// 业务约定：订单类型为 1 表示预约挂号（具体值请参考 OrderMain 中的 type 字段定义）
return order != null && order.getType() != null && order.getType() == 1;
}
// 其余业务方法保持原有实现
// ...
}