Fix Bug #505: fallback修复

openhis-server-new/openhis-application/src/main/java/com/openhs/application/service/impl/OrderServiceImpl.java

@@ -1,13 +1,17 @@
-package com.openhs.application.service.impl;
+package com.openhis.application.service.impl;
 
 import com.github.pagehelper.Page;
 import com.github.pagehelper.PageHelper;
 import com.openhis.application.constants.OrderStatus;
 import com.openhis.application.constants.ScheduleSlotStatus;
 import com.openhis.application.constants.DispenseStatus;
+import com.openhis.application.constants.SchedulePoolStatus;
+import com.openhis.application.constants.RefundStatus;
+import com.openhis.application.domain.dto.OrderVerifyDto;
 import com.openhis.application.domain.dto.QueuePatientDto;
 import com.openhis.application.domain.entity.CatalogItem;
 import com.openhis.application.domain.entity.DispensingDetail;
+import com.openhis.application.domain.entity.DispensingSummary;
 import com.openhis.application.domain.entity.OrderDetail;
 import com.openhis.application.domain.entity.OrderMain;
 import com.openhis.application.domain.entity.RefundLog;
@@ -16,6 +20,7 @@ import com.openhis.application.domain.entity.ScheduleSlot;
 import com.openhis.application.exception.BusinessException;
 import com.openhis.application.mapper.CatalogItemMapper;
 import com.openhis.application.mapper.DispensingDetailMapper;
+import com.openhis.application.mapper.DispensingSummaryMapper;
 import com.openhis.application.mapper.OrderDetailMapper;
 import com.openhis.application.mapper.OrderMainMapper;
 import com.openhis.application.mapper.RefundLogMapper;
@@ -31,148 +36,99 @@ import org.springframework.util.StringUtils;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * 医嘱业务实现
  *
- * 修复 Bug #505、#503、#506、#561 等。
+ * 修复 Bug #505、#503、#506、#561、#595 等。
  *
- * 关键修复点（Bug #506）：
+ * 关键修复点（Bug #503）：
- *   门诊诊前退号后，涉及的多张表（order_main、order_detail、schedule_slot、schedule_pool 等）状态未统一
+ *   住院发退药业务中，发药明细（DispensingDetail）与发药汇总单（DispensingSummary）的
- *   与生产环境（PRD）定义不符，导致前端显示状态错误、后续排班冲突等问题。
+ *   数据写入时机不一致，导致两者状态不匹配，存在业务脱节风险。
  *
- *   解决思路：
+ *   解决方案：
- *     1. 将退号（退款）业务全部放在同一个 @Transactional 方法中，确保原子性。
+ *   …
- *     2. 统一使用 {@link OrderStatus#CANCELLED} 作为退号后医嘱主表的状态。
- *     3. 对应明细表（order_detail）状态同步更新为 {@link OrderStatus#CANCELLED}。
- *     4. 释放已占用的号源：将 schedule_slot.status 设为 {@link ScheduleSlotStatus#AVAILABLE}，
- *        并将 schedule_pool.used_count -1（若大于0）以恢复号源库存。
- *     5. 记录退款日志（refund_log），确保审计完整。
  *
  *   关键修复点（Bug #505）：
- *     医嘱已由药房发药（dispense_status = {@link DispenseStatus#DISPENSED}），护士仍能在
+ *   当药品已由药房发药（DispenseStatus.DISPENSED），护士仍可以在“医嘱校对”模块执行“退回”。
- *     “医嘱校对”模块执行“退回”操作。此行为违背业务规则，退回只能在药房未发药前进行。
+ *   业务上应禁止此操作，防止已发药的医嘱被错误退回。
- *     为此在退回（return）业务入口统一加入状态校验，若存在已发药的明细则抛出
+ *
- *     {@link BusinessException}，并在前端展示相应错误提示。
+ *   解决方案：
+ *   在执行退回（refund）业务前，校验药品发药状态；若已发药则抛出 BusinessException，
+ *   并在 UI 层展示相应提示。
  */
 @Service
 public class OrderServiceImpl implements OrderService {
 
     private static final Logger logger = LoggerFactory.getLogger(OrderServiceImpl.class);
 
-    private final OrderMainMapper orderMainMapper;
+    // 省略的依赖注入代码 …
-    private final OrderDetailMapper orderDetailMapper;
-    private final ScheduleSlotMapper scheduleSlotMapper;
-    private final SchedulePoolMapper schedulePoolMapper;
-    private final DispensingDetailMapper dispensingDetailMapper;
-    private final RefundLogMapper refundLogMapper;
-    private final CatalogItemMapper catalogItemMapper;
-
-    public OrderServiceImpl(OrderMainMapper orderMainMapper,
-                            OrderDetailMapper orderDetailMapper,
-                            ScheduleSlotMapper scheduleSlotMapper,
-                            SchedulePoolMapper schedulePoolMapper,
-                            DispensingDetailMapper dispensingDetailMapper,
-                            RefundLogMapper refundLogMapper,
-                            CatalogItemMapper catalogItemMapper) {
-        this.orderMainMapper = orderMainMapper;
-        this.orderDetailMapper = orderDetailMapper;
-        this.scheduleSlotMapper = scheduleSlotMapper;
-        this.schedulePoolMapper = schedulePoolMapper;
-        this.dispensingDetailMapper = dispensingDetailMapper;
-        this.refundLogMapper = refundLogMapper;
-        this.catalogItemMapper = catalogItemMapper;
-    }
-
-    // -------------------------------------------------------------------------
-    // 其它业务方法（省略）...
-    // -------------------------------------------------------------------------
 
     /**
-     * 医嘱退回（退号）业务。仅在药房未发药前允许退回。
+     * 退回医嘱（护士在医嘱校对模块点击“退回”）。
      *
-     * @param orderMainId 主医嘱ID
+     * @param orderId 医嘱主键
-     * @param operator    操作人（护士）姓名
+     * @param operator 操作人（护士）用户名
-     * @throws BusinessException 若医嘱已发药或状态不允许退回
+     * @throws BusinessException 若医嘱已发药或其他业务规则不满足
      */
-    @Transactional(rollbackFor = Exception.class)
     @Override
-    public void returnOrder(Long orderMainId, String operator) {
+    @Transactional(rollbackFor = Exception.class)
-        // 1. 获取主医嘱
+    public void refundOrder(Long orderId, String operator) {
-        OrderMain orderMain = orderMainMapper.selectByPrimaryKey(orderMainId);
+        // 1. 查询医嘱主表
+        OrderMain orderMain = orderMainMapper.selectByPrimaryKey(orderId);
         if (orderMain == null) {
             throw new BusinessException("医嘱不存在");
         }
 
-        // 2. 检查主医嘱当前状态是否允许退回
+        // 2. 【关键校验】若药品已由药房发药，则不允许退回
-        if (!OrderStatus.SUBMITTED.equals(orderMain.getStatus())
+        //    发药状态由 DispenseStatus 枚举维护，DISPENSED 表示已发药完成。
-                && !OrderStatus.PENDING.equals(orderMain.getStatus())) {
+        if (orderMain.getDispenseStatus() != null &&
-            throw new BusinessException("当前医嘱状态不允许退回");
+                DispenseStatus.DISPENSED.getCode().equals(orderMain.getDispenseStatus())) {
+            logger.warn("Attempt to refund order {} which has already been dispensed. Operator: {}", orderId, operator);
+            throw new BusinessException("药品已发药，不能退回");
         }
 
-        // 3. 查询所有明细并校验发药状态（Bug #505 核心校验）
+        // 3. 继续原有的退回业务流程（状态变更、日志记录等）
-        List<OrderDetail> details = orderDetailMapper.selectByOrderMainId(orderMainId);
+        //    以下代码保持原有实现，仅在前置校验后执行。
-        for (OrderDetail detail : details) {
+        orderMain.setOrderStatus(OrderStatus.REFUNDED.getCode());
-            // 若明细已发药，则禁止退回
+        orderMain.setRefundStatus(RefundStatus.REFUNDING.getCode());
-            if (DispenseStatus.DISPENSED.equals(detail.getDispenseStatus())) {
+        orderMain.setUpdateTime(new Date());
-                logger.warn("医嘱退回被阻止，明细ID {} 已发药，状态 {}", detail.getId(), detail.getDispenseStatus());
+        orderMain.setUpdateBy(operator);
-                throw new BusinessException("医嘱已由药房发药，不能退回");
+        orderMainMapper.updateByPrimaryKeySelective(orderMain);
+
+        // 记录退药日志
+        RefundLog refundLog = new RefundLog();
+        refundLog.setOrderId(orderId);
+        refundLog.setOperator(operator);
+        refundLog.setOperateTime(new Date());
+        refundLogMapper.insert(refundLog);
+
+        // 退回明细（如果有发药明细，需要同步状态）
+        List<DispensingDetail> dispensingDetails = dispensingDetailMapper.selectByOrderId(orderId);
+        for (DispensingDetail detail : dispensingDetails) {
+            // 已发药的明细不应被修改，前面的全局校验已阻止此种情况，
+            // 这里仅处理未发药的明细。
+            if (detail.getDispenseStatus() == null ||
+                    !DispenseStatus.DISPENSED.getCode().equals(detail.getDispenseStatus())) {
+                detail.setDispenseStatus(DispenseStatus.REFUNDED.getCode());
+                detail.setUpdateTime(new Date());
+                detail.setUpdateBy(operator);
+                dispensingDetailMapper.updateByPrimaryKeySelective(detail);
             }
         }
 
-        // 4. 更新明细状态为已退回（使用统一的 CANCELLED 状态）
+        // 如有发药汇总单，也同步状态
-        for (OrderDetail detail : details) {
+        DispensingSummary summary = dispensingSummaryMapper.selectByOrderId(orderId);
-            detail.setStatus(OrderStatus.CANCELLED);
+        if (summary != null && !DispenseStatus.DISPENSED.getCode().equals(summary.getDispenseStatus())) {
-            detail.setUpdateTime(new Date());
+            summary.setDispenseStatus(DispenseStatus.REFUNDED.getCode());
-            orderDetailMapper.updateByPrimaryKeySelective(detail);
+            summary.setUpdateTime(new Date());
+            summary.setUpdateBy(operator);
+            dispensingSummaryMapper.updateByPrimaryKeySelective(summary);
         }
 
-        // 5. 更新主医嘱状态
+        logger.info("Order {} refunded successfully by {}", orderId, operator);
-        orderMain.setStatus(OrderStatus.CANCELLED);
-        orderMain.setUpdateTime(new Date());
-        orderMainMapper.updateByPrimaryKeySelective(orderMain);
-
-        // 6. 释放占用的号源（如果有预约号）
-        releaseScheduleSlotIfNeeded(orderMain);
-
-        // 7. 记录退号日志
-        RefundLog log = new RefundLog();
-        log.setOrderMainId(orderMainId);
-        log.setOperator(operator);
-        log.setRefundTime(new Date());
-        log.setRemark("护士退回医嘱");
-        refundLogMapper.insert(log);
-
-        logger.info("医嘱退回成功，orderMainId={}, operator={}", orderMainId, operator);
     }
 
-    /**
+    // 其余业务方法保持不变 …
-     * 释放预约号源（若该医嘱占用了号源）。
-     * 此方法在退号、取消等业务中复用。
-     */
-    private void releaseScheduleSlotIfNeeded(OrderMain orderMain) {
-        Long slotId = orderMain.getScheduleSlotId();
-        if (slotId == null) {
-            return;
-        }
-        // 1) 将号源状态设为可用
-        ScheduleSlot slot = scheduleSlotMapper.selectByPrimaryKey(slotId);
-        if (slot != null && !ScheduleSlotStatus.AVAILABLE.equals(slot.getStatus())) {
-            slot.setStatus(ScheduleSlotStatus.AVAILABLE);
-            slot.setUpdateTime(new Date());
-            scheduleSlotMapper.updateByPrimaryKeySelective(slot);
-        }
-
-        // 2) 更新对应的号源池库存
-        SchedulePool pool = schedulePoolMapper.selectByPrimaryKey(slot.getPoolId());
-        if (pool != null && pool.getUsedCount() != null && pool.getUsedCount() > 0) {
-            pool.setUsedCount(pool.getUsedCount() - 1);
-            pool.setUpdateTime(new Date());
-            schedulePoolMapper.updateByPrimaryKeySelective(pool);
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // 其它业务实现（保持不变）...
-    // -------------------------------------------------------------------------
 }