【代码优化】商城：价格计算相关逻辑

yudao-module-mall/yudao-module-trade-biz/src/main/java/cn/iocoder/yudao/module/trade/controller/app/order/AppTradeOrderController.java

@@ -44,11 +44,9 @@ import org.springframework.web.bind.annotation.*;
 import java.time.LocalDateTime;
 import java.util.*;
 
-import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
 import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
 import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
 import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
-import static cn.iocoder.yudao.module.promotion.enums.ErrorCodeConstants.DISCOUNT_ACTIVITY_TYPE_NOT_EXISTS;
 
 @Tag(name = "用户 App - 交易订单")
 @RestController
@@ -314,7 +312,7 @@ public class AppTradeOrderController {
                 Integer newPrice = price * discountProductRespDTO.getDiscountPercent() / 100;
                 sku.setPrice(price - newPrice);
             }else{
-                throw exception(DISCOUNT_ACTIVITY_TYPE_NOT_EXISTS);
+                throw new IllegalArgumentException("限时折扣活动类型不存在");
             }
             return sku;
         }

yudao-module-mall/yudao-module-trade-biz/src/main/java/cn/iocoder/yudao/module/trade/convert/aftersale/AfterSaleConvert.java

@@ -43,9 +43,10 @@ public interface AfterSaleConvert {
             @Mapping(source = "afterSale.orderId", target = "merchantOrderId"),
             @Mapping(source = "afterSale.id", target = "merchantRefundId"),
             @Mapping(source = "afterSale.applyReason", target = "reason"),
-            @Mapping(source = "afterSale.refundPrice", target = "price")
+            @Mapping(source = "afterSale.refundPrice", target = "price"),
+            @Mapping(source = "orderProperties.payAppKey", target = "appKey")
     })
-    PayRefundCreateReqDTO convert(String userIp, AfterSaleDO afterSale);
+    PayRefundCreateReqDTO convert(String userIp, AfterSaleDO afterSale, TradeOrderProperties orderProperties);
 
     MemberUserRespVO convert(MemberUserRespDTO bean);
 

yudao-module-mall/yudao-module-trade-biz/src/main/java/cn/iocoder/yudao/module/trade/service/aftersale/AfterSaleServiceImpl.java

@@ -385,9 +385,8 @@ public class AfterSaleServiceImpl implements AfterSaleService {
             @Override
             public void afterCommit() {
                 // 创建退款单
-                PayRefundCreateReqDTO createReqDTO = AfterSaleConvert.INSTANCE.convert(userIp, afterSale)
-                        .setReason(StrUtil.format("退款【{}】", afterSale.getSpuName()));
-                createReqDTO.setAppKey(tradeOrderProperties.getPayAppKey());
+                PayRefundCreateReqDTO createReqDTO = AfterSaleConvert.INSTANCE.convert(userIp, afterSale, tradeOrderProperties)
+                        .setReason(StrUtil.format("退款【{}】", afterSale.getSpuName()));;
                 Long payRefundId = payRefundApi.createRefund(createReqDTO);
                 // 更新售后单的退款单号
                 tradeAfterSaleMapper.updateById(new AfterSaleDO().setId(afterSale.getId()).setPayRefundId(payRefundId));

yudao-module-mall/yudao-module-trade-biz/src/main/java/cn/iocoder/yudao/module/trade/service/price/bo/TradePriceCalculateRespBO.java

@@ -73,11 +73,10 @@ public class TradePriceCalculateRespBO {
      */
     private Long bargainActivityId;
 
-
     /**
      * 是否包邮
      */
-    private Boolean freeDelivery = false;
+    private Boolean freeDelivery;
 
     /**
      * 赠送的优惠劵

yudao-module-mall/yudao-module-trade-biz/src/main/java/cn/iocoder/yudao/module/trade/service/price/calculator/TradeDeliveryPriceCalculator.java

@@ -121,13 +121,11 @@ public class TradeDeliveryPriceCalculator implements TradePriceCalculator {
      * @return 是否包邮
      */
     private boolean isGlobalExpressFree(TradePriceCalculateRespBO result) {
-
         TradeConfigDO config = tradeConfigService.getTradeConfig();
-        return  result.getFreeDelivery() ||
-                (config != null
-                && Boolean.TRUE.equals(config.getDeliveryExpressFreeEnabled()) // 开启包邮
-                && result.getPrice().getPayPrice() >= config.getDeliveryExpressFreePrice()
-                ); // 满足包邮的价格
+        return config == null
+                || Boolean.TRUE.equals(config.getDeliveryExpressFreeEnabled()) // 开启包邮
+                || result.getFreeDelivery() //满减包邮
+                || result.getPrice().getPayPrice() >= config.getDeliveryExpressFreePrice(); // 满足包邮的价格
     }
 
     private void calculateDeliveryPrice(List<OrderItem> selectedSkus,

yudao-module-mall/yudao-module-trade-biz/src/main/java/cn/iocoder/yudao/module/trade/service/price/calculator/TradeDiscountActivityPriceCalculator.java

@@ -1,8 +1,8 @@
 package cn.iocoder.yudao.module.trade.service.price.calculator;
 
-import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import cn.iocoder.yudao.framework.common.util.number.MoneyUtils;
 import cn.iocoder.yudao.module.member.api.level.MemberLevelApi;
 import cn.iocoder.yudao.module.member.api.level.dto.MemberLevelRespDTO;
 import cn.iocoder.yudao.module.member.api.user.MemberUserApi;
@@ -14,12 +14,10 @@ import cn.iocoder.yudao.module.promotion.enums.common.PromotionTypeEnum;
 import cn.iocoder.yudao.module.trade.enums.order.TradeOrderTypeEnum;
 import cn.iocoder.yudao.module.trade.service.price.bo.TradePriceCalculateReqBO;
 import cn.iocoder.yudao.module.trade.service.price.bo.TradePriceCalculateRespBO;
+import jakarta.annotation.Resource;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Component;
 
-import jakarta.annotation.Resource;
-
-import java.math.BigDecimal;
 import java.util.List;
 import java.util.Map;
 
@@ -30,6 +28,8 @@ import static cn.iocoder.yudao.module.trade.service.price.calculator.TradePriceC
 /**
  * 限时折扣的 {@link TradePriceCalculator} 实现类
  *
+ * 由于“会员折扣”和“限时折扣”是冲突，需要选择优惠金额多的，所以也放在这里计算
+ *
  * @author 芋道源码
  */
 @Component
@@ -50,132 +50,89 @@ public class TradeDiscountActivityPriceCalculator implements TradePriceCalculato
             return;
         }
 
-        boolean discount;
-        boolean vip;
-
-        //----------------------------------限时折扣计算-----------------------------------------
-        // 获得 SKU 对应的限时折扣活动
+        // 1.1 获得 SKU 对应的限时折扣活动
         List<DiscountProductRespDTO> discountProducts = discountActivityApi.getMatchDiscountProductList(
                 convertSet(result.getItems(), TradePriceCalculateRespBO.OrderItem::getSkuId));
-        if (CollUtil.isEmpty(discountProducts)) {
-            discount = false;
-        }else {
-            discount = true;
-        }
         Map<Long, DiscountProductRespDTO> discountProductMap = convertMap(discountProducts, DiscountProductRespDTO::getSkuId);
-
-
-
-        //----------------------------------会员计算-----------------------------------------
-        MemberLevelRespDTO level;
-        // 获得用户的会员等级
+        // 1.2 获得会员等级
         MemberUserRespDTO user = memberUserApi.getUser(param.getUserId());
-        if (user.getLevelId() != null && user.getLevelId() > 0) {
-            level = memberLevelApi.getMemberLevel(user.getLevelId());
-            if (level != null && level.getDiscountPercent() != null) {
-                vip = true;
-            }else {
-                vip = false;
-            }
-        }else {
-            level = null;
-            vip = false;
-        }
-
+        MemberLevelRespDTO level = user != null && user.getLevelId() > 0 ? memberLevelApi.getMemberLevel(user.getLevelId()) : null;
 
         // 2. 计算每个 SKU 的优惠金额
         result.getItems().forEach(orderItem -> {
-
-            //----------------------------------限时折扣计算-----------------------------------------
-            DiscountProductRespDTO discountProduct = null;
-            Integer newDiscountPrice = 0;
-            if (discount){
-                // 2.1  计算限时折扣优惠信息
-                discountProduct = discountProductMap.get(orderItem.getSkuId());
-                if (discountProduct != null) {
-                    // 2.2 计算优惠金额
-                    Integer newPayPrice = calculatePayPrice(discountProduct, orderItem);
-                    newDiscountPrice = orderItem.getPayPrice() - newPayPrice;
-                }
+            if (!orderItem.getSelected()) {
+                return;
+            }
+            // 2.1 计算限时折扣的优惠金额
+            DiscountProductRespDTO discountProduct = discountProductMap.get(orderItem.getSkuId());
+            Integer discountPrice = calculateActivityPrice(discountProduct, orderItem);
+            // 2.2 计算 VIP 优惠金额
+            Integer vipPrice = calculateVipPrice(level, orderItem);
+            if (discountPrice <= 0 && vipPrice <= 0) {
+                return;
             }
 
-
-            //----------------------------------会员计算-----------------------------------------
-            Integer vipPrice = 0;
-            if (vip){
-                // 2.3 计算会员优惠金额
-                vipPrice = calculateVipPrice(orderItem.getPayPrice(), level.getDiscountPercent());
-            }
-
-
-            // 2.4 记录优惠明细
-            // 注意，只有在选中的情况下，才会记录到优惠明细。否则仅仅是更新 SKU 优惠金额，用于展示
-            if (orderItem.getSelected()) {
-                if (discount && vip){
-                    if(newDiscountPrice > vipPrice){
-                        TradePriceCalculatorHelper.addPromotion(result, orderItem,
-                                discountProduct.getActivityId(), discountProduct.getActivityName(), PromotionTypeEnum.DISCOUNT_ACTIVITY.getType(),
-                                StrUtil.format("限时折扣：省 {} 元", formatPrice(newDiscountPrice)),
-                                newDiscountPrice);
-                        // 2.5 更新 SKU 优惠金额
-                        orderItem.setDiscountPrice(orderItem.getDiscountPrice() + newDiscountPrice);
-                    }else{
-                        TradePriceCalculatorHelper.addPromotion(result, orderItem,
-                                level.getId(), level.getName(), PromotionTypeEnum.MEMBER_LEVEL.getType(),
-                                String.format("会员等级折扣：省 %s 元", formatPrice(vipPrice)),
-                                vipPrice);
-                        // 2.5 更新 SKU 的优惠金额
-                        orderItem.setVipPrice(vipPrice);
-                    }
-                }else if (discount){
-                    TradePriceCalculatorHelper.addPromotion(result, orderItem,
-                            discountProduct.getActivityId(), discountProduct.getActivityName(), PromotionTypeEnum.DISCOUNT_ACTIVITY.getType(),
-                            StrUtil.format("限时折扣：省 {} 元", formatPrice(newDiscountPrice)),
-                            newDiscountPrice);
-                    // 2.5 更新 SKU 优惠金额
-                    orderItem.setDiscountPrice(orderItem.getDiscountPrice() + newDiscountPrice);
-                }else if (vip){
-                    TradePriceCalculatorHelper.addPromotion(result, orderItem,
-                            level.getId(), level.getName(), PromotionTypeEnum.MEMBER_LEVEL.getType(),
-                            String.format("会员等级折扣：省 %s 元", formatPrice(vipPrice)),
-                            vipPrice);
-                    // 2.5 更新 SKU 的优惠金额
-                    orderItem.setVipPrice(vipPrice);
-                }
+            // 3. 选择优惠金额多的
+            if (discountPrice > vipPrice) {
+                TradePriceCalculatorHelper.addPromotion(result, orderItem,
+                        discountProduct.getActivityId(), discountProduct.getActivityName(), PromotionTypeEnum.DISCOUNT_ACTIVITY.getType(),
+                        StrUtil.format("限时折扣：省 {} 元", formatPrice(discountPrice)),
+                        discountPrice);
+                // 更新 SKU 优惠金额
+                orderItem.setDiscountPrice(orderItem.getDiscountPrice() + discountPrice);
+            } else {
+                assert level != null;
+                TradePriceCalculatorHelper.addPromotion(result, orderItem,
+                        level.getId(), level.getName(), PromotionTypeEnum.MEMBER_LEVEL.getType(),
+                        String.format("会员等级折扣：省 %s 元", formatPrice(vipPrice)),
+                        vipPrice);
+                // 更新 SKU 的优惠金额
+                orderItem.setVipPrice(vipPrice);
             }
 
+            // 4. 分摊优惠
             TradePriceCalculatorHelper.recountPayPrice(orderItem);
+            TradePriceCalculatorHelper.recountAllPrice(result);
         });
-        TradePriceCalculatorHelper.recountAllPrice(result);
-    }
-
-    private Integer calculatePayPrice(DiscountProductRespDTO discountProduct,
-                                      TradePriceCalculateRespBO.OrderItem orderItem) {
-        Integer price = orderItem.getPayPrice();
-        if (PromotionDiscountTypeEnum.PRICE.getType().equals(discountProduct.getDiscountType())) { // 减价
-            price -= discountProduct.getDiscountPrice() * orderItem.getCount();
-        } else if (PromotionDiscountTypeEnum.PERCENT.getType().equals(discountProduct.getDiscountType())) { // 打折
-            price = price * discountProduct.getDiscountPercent() / 100;
-        } else {
-            throw new IllegalArgumentException(String.format("优惠活动的商品(%s) 的优惠类型不正确", discountProduct));
-        }
-        return price;
     }
 
     /**
-     * 计算会员 VIP 优惠价格
+     * 计算优惠活动的价格
      *
-     * @param price 原价
-     * @param discountPercent 折扣
+     * @param discount 优惠活动
+     * @param orderItem 交易项
      * @return 优惠价格
      */
-    public Integer calculateVipPrice(Integer price, Integer discountPercent) {
-        if (discountPercent == null) {
+    private Integer calculateActivityPrice(DiscountProductRespDTO discount,
+                                           TradePriceCalculateRespBO.OrderItem orderItem) {
+        if (discount == null) {
             return 0;
         }
-        BigDecimal divide = new BigDecimal(price).multiply(new BigDecimal(discountPercent)).divide(new BigDecimal(100));
-        Integer newPrice =  divide.intValue();
-        return price - newPrice;
+        Integer newPrice = orderItem.getPayPrice();
+        if (PromotionDiscountTypeEnum.PRICE.getType().equals(discount.getDiscountType())) { // 减价
+            newPrice -= discount.getDiscountPrice() * orderItem.getCount();
+        } else if (PromotionDiscountTypeEnum.PERCENT.getType().equals(discount.getDiscountType())) { // 打折
+            newPrice = newPrice * discount.getDiscountPercent() / 100;
+        } else {
+            throw new IllegalArgumentException(String.format("优惠活动的商品(%s) 的优惠类型不正确", discount));
+        }
+        return orderItem.getPayPrice() - newPrice;
+    }
+
+    /**
+     * 计算会员 VIP 的优惠价格
+     *
+     * @param level 会员等级
+     * @param orderItem 交易项
+     * @return 优惠价格
+     */
+    public Integer calculateVipPrice(MemberLevelRespDTO level,
+                                     TradePriceCalculateRespBO.OrderItem orderItem) {
+        if (level == null || level.getDiscountPercent() == null) {
+            return 0;
+        }
+        Integer newPrice = MoneyUtils.calculateRatePrice(orderItem.getPayPrice(), level.getDiscountPercent().doubleValue());
+        return orderItem.getPayPrice() - newPrice;
     }
 
 }

yudao-module-mall/yudao-module-trade-biz/src/main/java/cn/iocoder/yudao/module/trade/service/price/calculator/TradeMemberLevelPriceCalculator.java

@@ -1,93 +0,0 @@
-package cn.iocoder.yudao.module.trade.service.price.calculator;
-
-import cn.hutool.core.util.ObjectUtil;
-import cn.iocoder.yudao.module.member.api.level.MemberLevelApi;
-import cn.iocoder.yudao.module.member.api.level.dto.MemberLevelRespDTO;
-import cn.iocoder.yudao.module.member.api.user.MemberUserApi;
-import cn.iocoder.yudao.module.member.api.user.dto.MemberUserRespDTO;
-import cn.iocoder.yudao.module.promotion.enums.common.PromotionTypeEnum;
-import cn.iocoder.yudao.module.trade.enums.order.TradeOrderTypeEnum;
-import cn.iocoder.yudao.module.trade.service.price.bo.TradePriceCalculateReqBO;
-import cn.iocoder.yudao.module.trade.service.price.bo.TradePriceCalculateRespBO;
-import org.springframework.core.annotation.Order;
-import org.springframework.stereotype.Component;
-
-import jakarta.annotation.Resource;
-
-import static cn.iocoder.yudao.module.trade.service.price.calculator.TradePriceCalculatorHelper.formatPrice;
-
-/**
- * 会员 VIP 折扣的 {@link TradePriceCalculator} 实现类
- *
- * @author 芋道源码
- */
-@Component
-@Order(TradePriceCalculator.ORDER_MEMBER_LEVEL)
-public class TradeMemberLevelPriceCalculator implements TradePriceCalculator {
-
-    @Resource
-    private MemberLevelApi memberLevelApi;
-    @Resource
-    private MemberUserApi memberUserApi;
-
-    /**
-     * 会员计算迁移到限时优惠计算里
-     * @param param
-     * @param result
-     */
-    @Override
-    public void calculate(TradePriceCalculateReqBO param, TradePriceCalculateRespBO result) {
-//        // 0. 只有【普通】订单，才计算该优惠
-//        if (ObjectUtil.notEqual(result.getType(), TradeOrderTypeEnum.NORMAL.getType())) {
-//            return;
-//        }
-//        // 1. 获得用户的会员等级
-//        MemberUserRespDTO user = memberUserApi.getUser(param.getUserId());
-//        if (user.getLevelId() == null || user.getLevelId() <= 0) {
-//            return;
-//        }
-//        MemberLevelRespDTO level = memberLevelApi.getMemberLevel(user.getLevelId());
-//        if (level == null || level.getDiscountPercent() == null) {
-//            return;
-//        }
-//
-//        // 2. 计算每个 SKU 的优惠金额
-//        result.getItems().forEach(orderItem -> {
-//            // 2.1 计算优惠金额
-//            Integer vipPrice = calculateVipPrice(orderItem.getPayPrice(), level.getDiscountPercent());
-//            if (vipPrice <= 0) {
-//                return;
-//            }
-//
-//            // 2.2 记录优惠明细
-//            if (orderItem.getSelected()) {
-//                // 注意，只有在选中的情况下，才会记录到优惠明细。否则仅仅是更新 SKU 优惠金额，用于展示
-//                TradePriceCalculatorHelper.addPromotion(result, orderItem,
-//                        level.getId(), level.getName(), PromotionTypeEnum.MEMBER_LEVEL.getType(),
-//                        String.format("会员等级折扣：省 %s 元", formatPrice(vipPrice)),
-//                        vipPrice);
-//            }
-//
-//            // 2.3 更新 SKU 的优惠金额
-//            orderItem.setVipPrice(vipPrice);
-//            TradePriceCalculatorHelper.recountPayPrice(orderItem);
-//        });
-//        TradePriceCalculatorHelper.recountAllPrice(result);
-    }
-
-    /**
-     * 计算会员 VIP 优惠价格
-     *
-     * @param price 原价
-     * @param discountPercent 折扣
-     * @return 优惠价格
-     */
-    public Integer calculateVipPrice(Integer price, Integer discountPercent) {
-        if (discountPercent == null) {
-            return 0;
-        }
-        Integer newPrice = price * discountPercent / 100;
-        return price - newPrice;
-    }
-
-}

yudao-module-mall/yudao-module-trade-biz/src/main/java/cn/iocoder/yudao/module/trade/service/price/calculator/TradePriceCalculator.java

@@ -13,8 +13,6 @@ import cn.iocoder.yudao.module.trade.service.price.bo.TradePriceCalculateRespBO;
  */
 public interface TradePriceCalculator {
 
-    int ORDER_MEMBER_LEVEL = 5;
-
     int ORDER_SECKILL_ACTIVITY = 8;
     int ORDER_BARGAIN_ACTIVITY = 8;
     int ORDER_COMBINATION_ACTIVITY = 8;

yudao-module-mall/yudao-module-trade-biz/src/main/java/cn/iocoder/yudao/module/trade/service/price/calculator/TradeRewardActivityPriceCalculator.java

@@ -23,10 +23,8 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 
-import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
 import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;
 import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.filterList;
-import static cn.iocoder.yudao.module.promotion.enums.ErrorCodeConstants.REWARD_ACTIVITY_TYPE_NOT_EXISTS;
 import static cn.iocoder.yudao.module.trade.service.price.calculator.TradePriceCalculatorHelper.formatPrice;
 
 // TODO @puhui999：相关的单测，建议改一改
@@ -81,8 +79,10 @@ public class TradeRewardActivityPriceCalculator implements TradePriceCalculator
         Integer newDiscountPrice = rule.getDiscountPrice();
         // 2.2 计算分摊的优惠金额
         List<Integer> divideDiscountPrices = TradePriceCalculatorHelper.dividePrice(orderItems, newDiscountPrice);
-        //计算是否包邮
-        result.setFreeDelivery(rule.getFreeDelivery());
+        // 2.3 计算是否包邮
+        if (Boolean.TRUE.equals(rule.getFreeDelivery())) {
+            result.setFreeDelivery(true);
+        }
 
         // 3.1 记录使用的优惠劵
         result.setCouponId(param.getCouponId());
@@ -132,16 +132,17 @@ public class TradeRewardActivityPriceCalculator implements TradePriceCalculator
     private List<TradePriceCalculateRespBO.OrderItem> filterMatchActivityOrderItems(TradePriceCalculateRespBO result,
                                                                                     RewardActivityMatchRespDTO rewardActivity) {
         Integer productScope = rewardActivity.getProductScope();
-        if(PromotionProductScopeEnum.isAll(productScope)){
+        if (PromotionProductScopeEnum.isAll(productScope)){
             return result.getItems();
-        }else if (PromotionProductScopeEnum.isSpu(productScope)) {
+        } else if (PromotionProductScopeEnum.isSpu(productScope)) {
             return filterList(result.getItems(),
                     orderItem -> CollUtil.contains(rewardActivity.getProductScopeValues(), orderItem.getSpuId()));
-        }else if (PromotionProductScopeEnum.isCategory(productScope)) {
+        } else if (PromotionProductScopeEnum.isCategory(productScope)) {
             return filterList(result.getItems(),
                     orderItem -> CollUtil.contains(rewardActivity.getProductScopeValues(), orderItem.getCategoryId()));
-        }else{
-            throw exception(REWARD_ACTIVITY_TYPE_NOT_EXISTS);
+        } else {
+            throw new IllegalArgumentException(StrUtil.format("满减送活动({})的类型({})不存在",
+                    rewardActivity.getId(), productScope));
         }
     }