订单相关

src/main/java/com/dk/mdm/mapper/ivt/OutboundItemMapper.xml

@@ -230,7 +230,7 @@
         SELECT
         <include refid="Base_Column_List"/>
         FROM t_psi_outbound_item
-        WHERE outId = #{id}::uuid
+        WHERE out_id = #{id}::uuid
         for update
     </select>
 

src/main/java/com/dk/mdm/mapper/sale/OrderItemMapper.java

@@ -10,43 +10,50 @@ import org.springframework.stereotype.Repository;
 import java.util.List;
 
 /**
-*  销售明细 Mapper
-*/
+ * 销售明细 Mapper
+ */
 @Repository
-public interface OrderItemMapper extends BaseMapper<OrderItem>{
+public interface OrderItemMapper extends BaseMapper<OrderItem> {
     /**
-     * @desc   : 根据条件进行查询
+     * @desc : 根据条件进行查询
      * @author : 付斌
-     * @date   : 2024-02-28 10:18
+     * @date : 2024-02-28 10:18
      */
     List<OrderItemResponse> selectByCond(OrderItemQuery orderQuery);
 
     /**
-     * @desc   : 根据条件进行查询（数量）
+     * @desc : 根据条件进行查询（数量）
      * @author : 付斌
-     * @date   : 2024-02-28 10:19
+     * @date : 2024-02-28 10:19
      */
     Long countByCond(OrderItemQuery orderQuery);
 
     /**
-     * @desc   : 删除明细
+     * @desc : 删除明细
      * @author : 付斌
-     * @date   : 2024-03-03 14:17
+     * @date : 2024-03-03 14:17
      */
     int deleteById(@Param("id") String id);
 
     /**
-     * @desc   : 根据条件进行查询（出库用）
+     * @desc : 根据条件进行查询（出库用）
      * @author : 付斌
-     * @date   : 2024-03-06 12:59
+     * @date : 2024-03-06 12:59
      */
     List<OrderItemResponse> selectByCondForOut(OrderItemQuery orderQuery);
 
     /**
-     * @desc   : 根据条件进行查询（退货用）
+     * @desc : 根据条件进行查询（退货用）
      * @author : 付斌
-     * @date   : 2024-03-06 12:59
+     * @date : 2024-03-06 12:59
      */
     List<OrderItemResponse> selectByCondForReturn(OrderItemQuery orderQuery);
+
+    /**
+     * @desc :根据主表主键锁定表t_psi_order_item的一行数据
+     * @author : 付斌
+     * @date : 2024-03-09 15:44
+     */
+    List<OrderItem> selectByZIdForUpdate(String id);
 }
 

src/main/java/com/dk/mdm/mapper/sale/OrderItemMapper.xml

@@ -205,6 +205,15 @@
         for update
     </select>
 
+    <!-- 根据主表主键锁定表t_psi_order_item的一行数据 -->
+    <select id="selectByZIdForUpdate" resultMap="BaseResultMap">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM t_psi_order_item
+        WHERE order_id = #{id}::uuid
+        for update
+    </select>
+
     <!-- 根据主键锁定表t_psi_order_item的多行数据 -->
     <select id="selectByIdsForUpdate" resultMap="BaseResultMap">
         SELECT

src/main/java/com/dk/mdm/mapper/sale/OutReturnItemMapper.java

@@ -26,5 +26,12 @@ public interface OutReturnItemMapper extends BaseMapper<OutReturnItem>{
      * @date   : 2024-02-28 10:19
      */
     Long countByCond(OutReturnItemQuery outReturnItemQuery);
+
+    /**
+     * @desc   : 根据主表主键锁定表t_psi_out_return_item的多行数据
+     * @author : 付斌
+     * @date   : 2024-03-09 11:36
+     */
+    List<OutReturnItem> selectByZIdForUpdate(String id);
 }
 

src/main/java/com/dk/mdm/mapper/sale/OutReturnItemMapper.xml

@@ -222,6 +222,15 @@
         for update
     </select>
 
+    <!-- 根据主键锁定表t_psi_out_return_item的多行数据 -->
+    <select id="selectByZIdForUpdate" resultMap="BaseResultMap">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM t_psi_out_return_item
+        WHERE return_id = #{id}::uuid
+        for update
+    </select>
+
     <insert id="insertBatch">
         insert into t_psi_out_return_item
         (

src/main/java/com/dk/mdm/service/ivt/OutboundService.java

@@ -189,8 +189,6 @@ public class OutboundService extends BaseService<Outbound> {
         OrderItem orderItemForUpdate;
         // 订单明细实体
         OutboundItem outboundItemForUpdate;
-        // 转化实体
-        Outbound outbound = outboundConvert.convertToPo(outboundVO);
 
         // 编辑出库明细
         List<OutboundItemVO> editOutboundItemVOList = outboundVO.getItemList().stream().filter(it -> it.getItemId() != null).collect(Collectors.toList());
@@ -218,16 +216,21 @@ public class OutboundService extends BaseService<Outbound> {
             outboundItemService.updateByUuid(outboundItem);
         }
 
-        Outbound outboundForUpdate = outboundMapper.selectByIdForUpdate(outboundVO.getOutId());
-
-        // 更新订单上的退货数量，金额
-        Order orderForUpdate = orderMapper.selectByIdForUpdate(outboundVO.getFromId());
+        // 计算订单明细的出库中数量，金额合计
+        List<OrderItem> orderItemList = orderItemMapper.selectByZIdForUpdate(outboundVO.getFromId());
+        OrderItem orderItem = orderItemList.stream().reduce((x, y) -> {
+            OrderItem item = new OrderItem();
+            item.setOutingQty(x.getOutingQty().add(y.getOutingQty()));
+            item.setOutingAmt(x.getOutingAmt().add(y.getOutingAmt()));
+            return item;
+        }).get();
+        // 更新订单上的出库中数量，金额
         Order orderUpdate = new Order();
-        orderUpdate.setOutingQty(orderForUpdate.getOutingQty().subtract(outboundForUpdate.getOutingQty()).add(outboundForUpdate.getOutingQty()))
-                .setOutingAmt(orderForUpdate.getOutingAmt().subtract(outboundForUpdate.getOutingAmt()).add(outboundForUpdate.getOutingAmt()))
-                .setOrderId(outboundVO.getFromId());
+        orderUpdate.setOutingQty(orderItem.getOutingQty()).setOutingAmt(orderItem.getOutingAmt()).setOrderId(outboundVO.getFromId());
         orderService.updateByUuid(orderUpdate);
 
+        // 转化实体、更新出库单总表
+        Outbound outbound = outboundConvert.convertToPo(outboundVO);
         return ResponseResultUtil.success(super.update(outbound, new UpdateWrapper<Outbound>().lambda().eq(Outbound::getOutId,
                 UUID.fromString(outbound.getOutId()))));
     }
@@ -244,8 +247,7 @@ public class OutboundService extends BaseService<Outbound> {
             throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.ISEXISTS_AFTER_OPERATE.getMessage());
         }
 
-        double sumOutingQty = 0;    // 合计出库中数量
-        double sumOutingAmt = 0;    // 合计出库中金额
+        // 查出并锁定所有的出库明细
         List<OutboundItem> outboundItemList = outboundItemMapper.selectByZIdForUpdate(id);
         OrderItem orderItemForUpdate;
         for (OutboundItem outboundItemForUpdate : outboundItemList) {
@@ -256,22 +258,19 @@ public class OutboundService extends BaseService<Outbound> {
                     .setOutingAmt(orderItemForUpdate.getOutingAmt().subtract(outboundItemForUpdate.getOutingAmt()))
                     .setItemId(orderItemForUpdate.getItemId());
             orderItemService.updateByUuid(orderItemUpdate);
-
-            // 累加出库中数量，金额
-            sumOutingQty += outboundItemForUpdate.getOutingQty().doubleValue();
-            sumOutingAmt += outboundItemForUpdate.getOutingAmt().doubleValue();
         }
 
-        // 更新订单上的出库中数量，金额，状态
-        Order orderForUpdate = orderMapper.selectByIdForUpdate(outbound.getFromId());
+        // 计算订单明细的出库中数量，金额合计
+        List<OrderItem> orderItemList = orderItemMapper.selectByZIdForUpdate(outbound.getFromId());
+        OrderItem orderItem = orderItemList.stream().reduce((x, y) -> {
+            OrderItem item = new OrderItem();
+            item.setOutingQty(x.getOutingQty().add(y.getOutingQty()));
+            item.setOutingAmt(x.getOutingAmt().add(y.getOutingAmt()));
+            return item;
+        }).get();
+        // 更新订单上的出库中数量，金额
         Order orderUpdate = new Order();
-        orderUpdate.setOutingQty(orderForUpdate.getOutingQty().subtract(new BigDecimal(sumOutingQty)))
-                .setOutingAmt(orderForUpdate.getOutingAmt().subtract(new BigDecimal(sumOutingAmt)))
-                .setOrderId(outbound.getFromId());
-        // 如果出库中数量为0了，更新状态为待出库
-        if (orderUpdate.getOutingQty().compareTo(BigDecimal.ZERO) == 0) {
-            orderUpdate.setOutStatus(Constant.OutStatus.DAICHUKU.getName());
-        }
+        orderUpdate.setOutingQty(orderItem.getOutingQty()).setOutingAmt(orderItem.getOutingAmt()).setOrderId(outbound.getFromId());
         orderService.updateByUuid(orderUpdate);
 
         // 作废

src/main/java/com/dk/mdm/service/sale/OrderService.java

@@ -137,13 +137,6 @@ public class OrderService extends BaseService<Order> {
         // 订单总单保存
         super.insert(order);
 
-//        // 更新单号
-//        Order updateOrder = new Order();
-//        updateOrder.setOrderNo(commonMapper.getDocNo(order.getCpId(), order.getOrderId(), Constant.DocumentType.ORDER_CHASE.getName()));
-//        updateOrder.setOrderId(order.getOrderId());
-//        super.update(updateOrder,new UpdateWrapper<Order>().lambda().eq(Order::getOrderId,
-//                UUID.fromString(updateOrder.getOrderId())));
-
         // 订单明细保存
         if (orderVO.getItemList() != null && orderVO.getItemList().size() > 0) {
             for (OrderItemVO orderItemVO : orderVO.getItemList()) {
@@ -210,9 +203,9 @@ public class OrderService extends BaseService<Order> {
      * @date : 2024-03-08 16:38
      */
     public ResponseResultVO<?> invalid(String id) {
-        Order order = orderMapper.selectByIdForUpdate(id);
-        // 如果状态不是待出库，出库中数量不是0，不能作废
-        if (!order.getOutStatus().equals(Constant.OutStatus.DAICHUKU.getName()) || order.getOutingQty().compareTo(BigDecimal.ZERO) != 0) {
+        Order orderForUpdate = orderMapper.selectByIdForUpdate(id);
+        // 如果出库中数量不是0，不能作废
+        if (orderForUpdate.getOutingQty().compareTo(BigDecimal.ZERO) != 0) {
             throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.ISEXISTS_AFTER_OPERATE.getMessage());
         }
         // 作废

src/main/java/com/dk/mdm/service/sale/OutReturnService.java

@@ -39,11 +39,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-import java.util.stream.Collectors;
+import java.util.*;
 
 @Service
 @Transactional
@@ -151,16 +147,16 @@ public class OutReturnService extends BaseService<OutReturn> {
 
         // 明细保存
         if (outReturnVO.getItemList() != null && outReturnVO.getItemList().size() > 0) {
-            double sumReturnQty = 0;    // 合计已出库退货数量
-            double sumReturnAmt = 0;    // 合计已出库退货金额
             OrderItem orderItemForUpdate;
             OutboundItem outboundItemForUpdate;
+            String outId = "";
             for (OutReturnItemVO outReturnItemVO : outReturnVO.getItemList()) {
+                outId = outReturnItemVO.getOutId();
                 OutReturnItem outReturnItem = outReturnItemConvert.convertToPo(outReturnItemVO);
                 outReturnItem.setReturnId(outReturn.getReturnId()).setCpId(outReturn.getCpId()).setIntoStatus(Constant.IntoStatus.DAIRUKU.getName());
                 outReturnItemMapper.insert(outReturnItem);
 
-                /*********************  反写出库已出库退货数量、金额 begin **********************/
+                /*********************  反写出库明细退货数量、金额 begin **********************/
                 outboundItemForUpdate = outboundItemMapper.selectByIdForUpdate(outReturnItem.getOutItemId());
                 // 如果出库数量小于订单上已退货+本次退货数量
                 if (outboundItemForUpdate.getOutQty().compareTo(outboundItemForUpdate.getReturnQty().add(outReturnItem.getItemQty())) == -1) {
@@ -171,17 +167,10 @@ public class OutReturnService extends BaseService<OutReturn> {
                         .setReturnAmt(outboundItemForUpdate.getReturnAmt().add(outReturnItem.getItemAmt()))
                         .setItemId(outboundItemForUpdate.getItemId());
                 outboundItemService.updateByUuid(outboundItemUpdate);
+                /*********************  反写出库明细退货数量、金额 end **********************/
 
-                // 更新出库单上的退货数量，金额
-                Outbound outboundForUpdate = outboundMapper.selectByIdForUpdate(outReturnItem.getOutId());
-                Outbound outboundUpdate = new Outbound();
-                outboundUpdate.setReturnQty(outboundForUpdate.getReturnQty().add(outReturnItem.getItemQty()))
-                        .setReturnAmt(outboundForUpdate.getReturnAmt().add(outReturnItem.getItemAmt()))
-                        .setOutId(outReturnItem.getOutId());
-                outboundService.updateByUuid(outboundUpdate);
-                /*********************  反写出库已出库退货数量、金额 end **********************/
 
-                /*********************  反写订单明细已出库退货数量、金额 begin **********************/
+                /*********************  反写订单明细退货数量、金额 begin **********************/
                 orderItemForUpdate = orderItemMapper.selectByIdForUpdate(outReturnItem.getOrderItemId());
                 // 如果出库数量小于订单上已退货+本次退货数量
                 if (orderItemForUpdate.getOutQty().compareTo(orderItemForUpdate.getReturnQty().add(outReturnItem.getItemQty())) == -1) {
@@ -192,33 +181,102 @@ public class OutReturnService extends BaseService<OutReturn> {
                         .setReturnAmt(orderItemForUpdate.getReturnAmt().add(outReturnItem.getItemAmt()))
                         .setItemId(orderItemForUpdate.getItemId());
                 orderItemService.updateByUuid(orderItemUpdate);
-                // 累加退货数量，金额
-                sumReturnQty += outReturnItem.getItemQty().doubleValue();
-                sumReturnAmt += outReturnItem.getItemAmt().doubleValue();
-                /*********************  反写订单明细已出库退货数量、金额 end **********************/
+                /*********************  反写订单明细退货数量、金额 end **********************/
             }
+
+            // 计算出库明细的退货数量，金额合计
+            List<OutboundItem> outboundItemList = outboundItemMapper.selectByZIdForUpdate(outId);
+            OutboundItem outboundItem = outboundItemList.stream().reduce((x, y) -> {
+                OutboundItem item = new OutboundItem();
+                item.setReturnQty(x.getReturnQty().add(y.getReturnQty()));
+                item.setReturnAmt(x.getReturnAmt().add(y.getReturnAmt()));
+                return item;
+            }).get();
+            // 更新出库单上的退货数量，金额
+            Outbound outboundUpdate = new Outbound();
+            outboundUpdate.setReturnQty(outboundItem.getReturnQty()).setReturnAmt(outboundItem.getReturnAmt()).setOutId(outId);
+            outboundService.updateByUuid(outboundUpdate);
+
+            // 计算订单明细的退货数量，金额合计
+            List<OrderItem> orderItemList = orderItemMapper.selectByZIdForUpdate(outReturnVO.getOrderId());
+            OrderItem orderItem = orderItemList.stream().reduce((x, y) -> {
+                OrderItem item = new OrderItem();
+                item.setReturnQty(x.getReturnQty().add(y.getReturnQty()));
+                item.setReturnAmt(x.getReturnAmt().add(y.getReturnAmt()));
+                return item;
+            }).get();
             // 更新订单上的退货数量，金额
-            Order orderForUpdate = orderMapper.selectByIdForUpdate(outReturnVO.getOrderId());
             Order orderUpdate = new Order();
-            orderUpdate.setReturnQty(orderForUpdate.getReturnQty().add(new BigDecimal(sumReturnQty)))
-                    .setReturnAmt(orderForUpdate.getReturnAmt().add(new BigDecimal(sumReturnAmt)))
-                    .setOrderId(outReturnVO.getOrderId());
+            orderUpdate.setReturnQty(orderItem.getReturnQty()).setReturnAmt(orderItem.getReturnAmt()).setOrderId(outReturnVO.getOrderId());
             orderService.updateByUuid(orderUpdate);
         }
         return ResponseResultUtil.success();
     }
 
     /**
-     * @desc   : 作废
+     * @desc : 作废
      * @author : 付斌
-     * @date   : 2024-03-08 16:38
+     * @date : 2024-03-08 16:38
      */
     public ResponseResultVO<?> invalid(String id) {
         OutReturn outReturnForUpdate = outReturnMapper.selectByIdForUpdate(id);
-        // 如果数量不是0，不能作废
+        // 如果入库数量不是0，不能作废
         if (outReturnForUpdate.getIntoQty().compareTo(BigDecimal.ZERO) != 0) {
             throw new BaseBusinessException(ResponseCodeEnum.OPERATE_FAIL.getCode(), ErrorCodeEnum.ISEXISTS_AFTER_OPERATE.getMessage());
         }
+
+        // 查出并锁定所有的退货明细
+        List<OutReturnItem> outReturnItemList = outReturnItemMapper.selectByZIdForUpdate(id);
+        OutboundItem outboundItemForUpdate;
+        OrderItem orderItemForUpdate;
+        String outId = "";
+        String orderId = "";
+        for (OutReturnItem outReturnItemForUpdate : outReturnItemList) {
+            outId = outReturnItemForUpdate.getOutId();
+            orderId = outReturnItemForUpdate.getOrderId();
+            outboundItemForUpdate = outboundItemMapper.selectByIdForUpdate(outReturnItemForUpdate.getOutItemId());
+            // 更新出库明细退货数量
+            OutboundItem outboundItemUpdate = new OutboundItem();
+            outboundItemUpdate.setReturnQty(outboundItemForUpdate.getReturnQty().subtract(outReturnItemForUpdate.getItemQty()))
+                    .setReturnAmt(outboundItemForUpdate.getReturnAmt().subtract(outReturnItemForUpdate.getItemAmt()))
+                    .setItemId(outboundItemForUpdate.getItemId());
+            outboundItemService.updateByUuid(outboundItemUpdate);
+
+            orderItemForUpdate = orderItemMapper.selectByIdForUpdate(outReturnItemForUpdate.getOrderItemId());
+            // 更新订单明细退货数量
+            OrderItem orderItemUpdate = new OrderItem();
+            orderItemUpdate.setReturnQty(orderItemForUpdate.getReturnQty().subtract(outReturnItemForUpdate.getItemQty()))
+                    .setReturnAmt(orderItemForUpdate.getReturnAmt().subtract(outReturnItemForUpdate.getItemAmt()))
+                    .setItemId(orderItemForUpdate.getItemId());
+            orderItemService.updateByUuid(orderItemUpdate);
+        }
+
+        // 计算出库明细的退货数量，金额合计
+        List<OutboundItem> outboundItemList = outboundItemMapper.selectByZIdForUpdate(outId);
+        OutboundItem outboundItem = outboundItemList.stream().reduce((x, y) -> {
+            OutboundItem item = new OutboundItem();
+            item.setReturnQty(x.getReturnQty().add(y.getReturnQty()));
+            item.setReturnAmt(x.getReturnAmt().add(y.getReturnAmt()));
+            return item;
+        }).get();
+        // 更新出库单上的退货数量，金额
+        Outbound outboundUpdate = new Outbound();
+        outboundUpdate.setReturnQty(outboundItem.getReturnQty()).setReturnAmt(outboundItem.getReturnAmt()).setOutId(outId);
+        outboundService.updateByUuid(outboundUpdate);
+
+        // 计算订单明细的退货数量，金额合计
+        List<OrderItem> orderItemList = orderItemMapper.selectByZIdForUpdate(orderId);
+        OrderItem orderItem = orderItemList.stream().reduce((x, y) -> {
+            OrderItem item = new OrderItem();
+            item.setReturnQty(x.getReturnQty().add(y.getReturnQty()));
+            item.setReturnAmt(x.getReturnAmt().add(y.getReturnAmt()));
+            return item;
+        }).get();
+        // 更新订单上的退货数量，金额
+        Order orderUpdate = new Order();
+        orderUpdate.setReturnQty(orderItem.getReturnQty()).setReturnAmt(orderItem.getReturnAmt()).setOrderId(orderId);
+        orderService.updateByUuid(orderUpdate);
+
         // 作废
         OutReturn outReturnUpdate = new OutReturn();
         outReturnUpdate.setFlgValid(false).setReturnId(id);