- 后端：Order 模块，解决报错问题。

order/order-application/src/main/java/cn/iocoder/mall/order/application/controller/users/OrderController.java

@@ -13,17 +13,14 @@ import cn.iocoder.mall.order.api.constant.OrderErrorCodeEnum;
 import cn.iocoder.mall.order.api.dto.CalcOrderPriceDTO;
 import cn.iocoder.mall.order.api.dto.OrderCreateDTO;
 import cn.iocoder.mall.order.api.dto.OrderQueryDTO;
-import cn.iocoder.mall.order.api.dto.OrderReturnApplyDTO;
 import cn.iocoder.mall.order.application.convert.CartConvert;
 import cn.iocoder.mall.order.application.convert.OrderConvertAPP;
-import cn.iocoder.mall.order.application.convert.OrderReturnConvert;
 import cn.iocoder.mall.order.application.po.user.OrderCreatePO;
-import cn.iocoder.mall.order.application.po.user.OrderReturnApplyPO;
 import cn.iocoder.mall.order.application.vo.UsersOrderConfirmCreateVO;
 import cn.iocoder.mall.user.sdk.context.UserSecurityContextHolder;
-import org.apache.dubbo.config.annotation.Reference;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
+import org.apache.dubbo.config.annotation.Reference;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
@@ -76,7 +73,7 @@ public class OrderController {
                                                            HttpServletRequest request) {
         Integer userId = UserSecurityContextHolder.getContext().getUserId();
         // 获得购物车中选中的商品
-        List<CartItemBO> cartItems = cartService.list(userId, true).getData();
+        List<CartItemBO> cartItems = cartService.list(userId, true);
         if (cartItems.isEmpty()) {
             return ServiceExceptionUtil.error(OrderErrorCodeEnum.ORDER_CREATE_CART_IS_EMPTY.getCode());
         }
@@ -105,12 +102,9 @@ public class OrderController {
                 .setUserId(UserSecurityContextHolder.getContext().getUserId())
                 .setItems(Collections.singletonList(new CalcOrderPriceDTO.Item(skuId, quantity, true)))
                 .setCouponCardId(couponCardId);
-        CommonResult<CalcOrderPriceBO> calcOrderPriceResult = cartService.calcOrderPrice(calcOrderPriceDTO);
+        CalcOrderPriceBO calcOrderPrice = cartService.calcOrderPrice(calcOrderPriceDTO);
-        if (calcOrderPriceResult.isError()) {
-            return CommonResult.error(calcOrderPriceResult);
-        }
         // 执行数据拼装
-        return CommonResult.success(CartConvert.INSTANCE.convert(calcOrderPriceResult.getData()));
+        return CommonResult.success(CartConvert.INSTANCE.convert(calcOrderPrice));
     }
 
     @PostMapping("confirm_receiving")

order/order-application/src/main/java/cn/iocoder/mall/order/application/controller/users/UsersCartController.java

@@ -23,6 +23,8 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
+import static cn.iocoder.common.framework.vo.CommonResult.success;
+
 @RestController
 @RequestMapping("users/cart")
 public class UsersCartController {
@@ -38,26 +40,17 @@ public class UsersCartController {
     public CommonResult<Integer> add(@RequestParam("skuId") Integer skuId,
                                      @RequestParam("quantity") Integer quantity) {
         // 添加到购物车
-        CommonResult<Boolean> addResult = cartService.add(UserSecurityContextHolder.getContext().getUserId(),
+        cartService.add(UserSecurityContextHolder.getContext().getUserId(), skuId, quantity);
-                skuId, quantity);
-        // 添加失败，则直接返回错误
-        if (addResult.isError()) {
-            return CommonResult.error(addResult);
-        }
         // 获得目前购物车商品总数量
-        return cartService.count(UserSecurityContextHolder.getContext().getUserId());
+        return success(cartService.count(UserSecurityContextHolder.getContext().getUserId()));
     }
 
     @PostMapping("update_quantity")
     public CommonResult<UsersCartDetailVO> updateQuantity(@RequestParam("skuId") Integer skuId, // TODO 芋艿，先暂用这个 VO 。等促销活动出来后，做调整
                                                           @RequestParam("quantity") Integer quantity) {
         // 添加到购物车
-        CommonResult<Boolean> updateQuantityResult = cartService.updateQuantity(UserSecurityContextHolder.getContext().getUserId(),
+        cartService.updateQuantity(UserSecurityContextHolder.getContext().getUserId(),
                 skuId, quantity);
-        // 添加失败，则直接返回错误
-        if (updateQuantityResult.isError()) {
-            return CommonResult.error(updateQuantityResult);
-        }
         // 获得目前购物车明细
         return getCartDetail();
     }
@@ -66,19 +59,14 @@ public class UsersCartController {
     public CommonResult<UsersCartDetailVO> updateSelected(@RequestParam("skuIds") Set<Integer> skuIds, // TODO 芋艿，先暂用这个 VO 。等促销活动出来后，做调整
                                                           @RequestParam("selected") Boolean selected) {
         // 添加到购物车
-        CommonResult<Boolean> updateSelectedResult = cartService.updateSelected(UserSecurityContextHolder.getContext().getUserId(),
+        cartService.updateSelected(UserSecurityContextHolder.getContext().getUserId(), skuIds, selected);
-                skuIds, selected);
-        // 添加失败，则直接返回错误
-        if (updateSelectedResult.isError()) {
-            return CommonResult.error(updateSelectedResult);
-        }
         // 获得目前购物车明细
         return getCartDetail();
     }
 
     @GetMapping("count")
     public CommonResult<Integer> count() {
-        return cartService.count(UserSecurityContextHolder.getContext().getUserId());
+        return success(cartService.count(UserSecurityContextHolder.getContext().getUserId()));
     }
 
     @GetMapping("/list")
@@ -88,50 +76,42 @@ public class UsersCartController {
 
     private CommonResult<UsersCartDetailVO> getCartDetail() {
         // 获得购物车中选中的
-        List<CartItemBO> cartItems = cartService.list(UserSecurityContextHolder.getContext().getUserId(), null).getData();
+        List<CartItemBO> cartItems = cartService.list(UserSecurityContextHolder.getContext().getUserId(), null);
         // 购物车为空时，构造空的 UsersOrderConfirmCreateVO 返回
         if (cartItems.isEmpty()) {
             UsersCartDetailVO result = new UsersCartDetailVO();
             result.setItemGroups(Collections.emptyList());
             result.setFee(new UsersCartDetailVO.Fee(0, 0, 0, 0));
-            return CommonResult.success(result);
+            return success(result);
         }
         // 计算商品价格
-        CommonResult<CalcOrderPriceBO> calcOrderPriceResult = list0(cartItems, null);
+        CalcOrderPriceBO calcOrder = list0(cartItems, null);
-        if (calcOrderPriceResult.isError()) {
-            return CommonResult.error(calcOrderPriceResult);
-        }
         // 执行数据拼装
-        return CommonResult.success(CartConvert.INSTANCE.convert2(calcOrderPriceResult.getData()));
+        return success(CartConvert.INSTANCE.convert2(calcOrder));
     }
 
     @GetMapping("/confirm_create_order")
     public CommonResult<UsersOrderConfirmCreateVO> getConfirmCreateOrder(@RequestParam(value = "couponCardId", required = false) Integer couponCardId) {
         Integer userId = UserSecurityContextHolder.getContext().getUserId();
         // 获得购物车中选中的
-        List<CartItemBO> cartItems = cartService.list(userId, true).getData();
+        List<CartItemBO> cartItems = cartService.list(userId, true);
         // 购物车为空时，构造空的 UsersOrderConfirmCreateVO 返回
         if (cartItems.isEmpty()) {
             UsersOrderConfirmCreateVO result = new UsersOrderConfirmCreateVO();
             result.setItemGroups(Collections.emptyList());
             result.setFee(new UsersOrderConfirmCreateVO.Fee(0, 0, 0, 0));
-            return CommonResult.success(result);
+            return success(result);
         }
         // 计算商品价格
-        CommonResult<CalcOrderPriceBO> calcOrderPriceResult = list0(cartItems, couponCardId);
+        CalcOrderPriceBO calcOrderPrice = list0(cartItems, couponCardId);
-        if (calcOrderPriceResult.isError()) {
-            return CommonResult.error(calcOrderPriceResult);
-        }
         // 获得优惠劵
-        CalcOrderPriceBO calcOrderPrice = calcOrderPriceResult.getData();
         List<CouponCardAvailableBO> couponCards = couponService.getCouponCardList(userId,
-                CartConvert.INSTANCE.convertList(calcOrderPrice.getItemGroups())).getData();
+                CartConvert.INSTANCE.convertList(calcOrderPrice.getItemGroups()));
         // 执行数据拼装
-        return CommonResult.success(CartConvert.INSTANCE.convert(calcOrderPrice)
+        return success(CartConvert.INSTANCE.convert(calcOrderPrice).setCouponCards(couponCards));
-                .setCouponCards(couponCards));
     }
 
-    private CommonResult<CalcOrderPriceBO> list0(List<CartItemBO> cartItems, Integer couponCardId) {
+    private CalcOrderPriceBO list0(List<CartItemBO> cartItems, Integer couponCardId) {
         // 创建计算的 DTO
         CalcOrderPriceDTO calcOrderPriceDTO = new CalcOrderPriceDTO()
                 .setUserId(UserSecurityContextHolder.getContext().getUserId())
@@ -148,12 +128,8 @@ public class UsersCartController {
     @PermitAll
     public CommonResult<UsersCalcSkuPriceVO> calcSkuPrice(@RequestParam("skuId") Integer skuId) {
         // 计算 sku 的价格
-        CommonResult<CalcSkuPriceBO> calcSkuPriceResult = cartService.calcSkuPrice(skuId);
+        CalcSkuPriceBO calcSkuPrice = cartService.calcSkuPrice(skuId);
-        // 返回结果
+        return success(CartConvert.INSTANCE.convert2(calcSkuPrice));
-        if (calcSkuPriceResult.isError()) {
-            return CommonResult.error(calcSkuPriceResult);
-        }
-        return CommonResult.success(CartConvert.INSTANCE.convert2(calcSkuPriceResult.getData()));
     }
 
     public CommonResult<Object> confirmOrder() {

order/order-service-api/src/main/java/cn/iocoder/mall/order/api/CartService.java

@@ -1,7 +1,8 @@
 package cn.iocoder.mall.order.api;
 
-import cn.iocoder.common.framework.vo.CommonResult;
+import cn.iocoder.mall.order.api.bo.CalcOrderPriceBO;
-import cn.iocoder.mall.order.api.bo.*;
+import cn.iocoder.mall.order.api.bo.CalcSkuPriceBO;
+import cn.iocoder.mall.order.api.bo.CartItemBO;
 import cn.iocoder.mall.order.api.dto.CalcOrderPriceDTO;
 import org.springframework.lang.Nullable;
 
@@ -20,7 +21,7 @@ public interface CartService {
      * @param quantity 数量
      * @return 是否成功
      */
-    CommonResult<Boolean> add(Integer userId, Integer skuId, Integer quantity);
+    Boolean add(Integer userId, Integer skuId, Integer quantity);
 
     /**
      * 购物车更新商品数量
@@ -30,7 +31,7 @@ public interface CartService {
      * @param quantity 数量
      * @return 是否成功
      */
-    CommonResult<Boolean> updateQuantity(Integer userId, Integer skuId, Integer quantity);
+    Boolean updateQuantity(Integer userId, Integer skuId, Integer quantity);
 
     /**
      * 购物车更新商品是否选中
@@ -40,7 +41,7 @@ public interface CartService {
      * @param selected 是否选中
      * @return 是否成功
      */
-    CommonResult<Boolean> updateSelected(Integer userId, Collection<Integer> skuIds, Boolean selected);
+    Boolean updateSelected(Integer userId, Collection<Integer> skuIds, Boolean selected);
 
     /**
      * 购物车删除商品
@@ -50,7 +51,7 @@ public interface CartService {
      *
      * @return 是否成功
      */
-    CommonResult<Boolean> deleteList(Integer userId, List<Integer> skuIds);
+    Boolean deleteList(Integer userId, List<Integer> skuIds);
 
     /**
      * 清空购物车
@@ -58,7 +59,7 @@ public interface CartService {
      * @param userId 用户编号
      * @return 是否成功
      */
-    CommonResult<Boolean> deleteAll(Integer userId);
+    Boolean deleteAll(Integer userId);
 
     /**
      * 查询用户在购物车中的商品数量
@@ -66,7 +67,7 @@ public interface CartService {
      * @param userId 用户编号
      * @return 商品数量
      */
-    CommonResult<Integer> count(Integer userId);
+    Integer count(Integer userId);
 
     /**
      * 显示买家购物车中的商品列表，并根据 selected 进行过滤。
@@ -75,7 +76,7 @@ public interface CartService {
      * @param selected 是否选中。若为空，则不进行筛选
      * @return 购物车中商品列表信息
      */
-    CommonResult<List<CartItemBO>> list(Integer userId, @Nullable  Boolean selected);
+    List<CartItemBO> list(Integer userId, @Nullable  Boolean selected);
 
     // ========== 购物车与订单相关的逻辑 ==========
 
@@ -85,7 +86,7 @@ public interface CartService {
      * @param calcOrderPriceDTO 计算订单金额 DTO
      * @return 计算订单金额结果
      */
-    CommonResult<CalcOrderPriceBO> calcOrderPrice(CalcOrderPriceDTO calcOrderPriceDTO);
+    CalcOrderPriceBO calcOrderPrice(CalcOrderPriceDTO calcOrderPriceDTO);
 
     /**
      * 计算指定商品 SKU 的金额，并返回计算结果
@@ -95,6 +96,6 @@ public interface CartService {
      * @param skuId 商品 SKU 编号
      * @return 计算订单金额结果
      */
-    CommonResult<CalcSkuPriceBO> calcSkuPrice(Integer skuId);
+    CalcSkuPriceBO calcSkuPrice(Integer skuId);
 
 }

order/order-service-impl/src/main/java/cn/iocoder/mall/order/biz/service/CartServiceImpl.java

@@ -2,7 +2,6 @@ package cn.iocoder.mall.order.biz.service;
 
 import cn.iocoder.common.framework.constant.CommonStatusEnum;
 import cn.iocoder.common.framework.util.ServiceExceptionUtil;
-import cn.iocoder.common.framework.vo.CommonResult;
 import cn.iocoder.mall.order.api.CartService;
 import cn.iocoder.mall.order.api.bo.CalcOrderPriceBO;
 import cn.iocoder.mall.order.api.bo.CalcSkuPriceBO;
@@ -48,12 +47,12 @@ public class CartServiceImpl implements CartService {
 
     @Override
     @SuppressWarnings("Duplicates")
-    public CommonResult<Boolean> add(Integer userId, Integer skuId, Integer quantity) {
+    public Boolean add(Integer userId, Integer skuId, Integer quantity) {
         // 查询 SKU 是否合法
         ProductSkuBO sku = productSpuService.getProductSku(skuId);
         if (sku == null
                 || CommonStatusEnum.DISABLE.getValue().equals(sku.getStatus())) { // sku 被禁用
-            return ServiceExceptionUtil.error(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
+            throw ServiceExceptionUtil.exception(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
         }
         // TODO 芋艿，后续基于商品是否上下架进一步完善。
         // 查询 CartItemDO
@@ -66,10 +65,10 @@ public class CartServiceImpl implements CartService {
         return add0(userId, sku, quantity);
     }
 
-    private CommonResult<Boolean> add0(Integer userId, ProductSkuBO sku, Integer quantity) {
+    private Boolean add0(Integer userId, ProductSkuBO sku, Integer quantity) {
         // 校验库存
         if (quantity > sku.getQuantity()) {
-            return ServiceExceptionUtil.error(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
+            throw ServiceExceptionUtil.exception(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
         }
         // 创建 CartItemDO 对象，并进行保存。
         CartItemDO item = new CartItemDO()
@@ -82,79 +81,79 @@ public class CartServiceImpl implements CartService {
         item.setCreateTime(new Date());
         cartMapper.insert(item);
         // 返回成功
-        return CommonResult.success(true);
+        return true;
     }
 
     @Override
     @SuppressWarnings("Duplicates")
-    public CommonResult<Boolean> updateQuantity(Integer userId, Integer skuId, Integer quantity) {
+    public Boolean updateQuantity(Integer userId, Integer skuId, Integer quantity) {
         // 查询 SKU 是否合法
         ProductSkuBO sku = productSpuService.getProductSku(skuId);
         if (sku == null
                 || CommonStatusEnum.DISABLE.getValue().equals(sku.getStatus())) { // sku 被禁用
-            return ServiceExceptionUtil.error(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
+            throw ServiceExceptionUtil.exception(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
         }
         // 查询 CartItemDO
         CartItemDO item = cartMapper.selectByUserIdAndSkuIdAndStatus(userId, skuId, CartItemStatusEnum.ENABLE.getValue());
         if (item == null) {
-            return ServiceExceptionUtil.error(OrderErrorCodeEnum.CARD_ITEM_NOT_FOUND.getCode());
+            throw ServiceExceptionUtil.exception(OrderErrorCodeEnum.CARD_ITEM_NOT_FOUND.getCode());
         }
         // TODO 芋艿，后续基于商品是否上下架进一步完善。
         return updateQuantity0(item, sku, quantity);
     }
 
-    private CommonResult<Boolean> updateQuantity0(CartItemDO item, ProductSkuBO sku, Integer quantity) {
+    private Boolean updateQuantity0(CartItemDO item, ProductSkuBO sku, Integer quantity) {
         // 校验库存
         if (item.getQuantity() + quantity > sku.getQuantity()) {
-            return ServiceExceptionUtil.error(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
+            throw ServiceExceptionUtil.exception(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
         }
         // 更新 CartItemDO
         cartMapper.updateQuantity(item.getId(), quantity);
         // 返回成功
-        return CommonResult.success(true);
+        return true;
     }
 
     @Override
-    public CommonResult<Boolean> updateSelected(Integer userId, Collection<Integer> skuIds, Boolean selected) {
+    public Boolean updateSelected(Integer userId, Collection<Integer> skuIds, Boolean selected) {
         // 更新 CartItemDO 们
         cartMapper.updateListByUserIdAndSkuId(userId, skuIds, selected, null);
         // 返回成功
-        return CommonResult.success(true);
+        return true;
     }
 
     @Override
-    public CommonResult<Boolean> deleteList(Integer userId, List<Integer> skuIds) {
+    public Boolean deleteList(Integer userId, List<Integer> skuIds) {
         // 更新 CartItemDO 们
         cartMapper.updateListByUserIdAndSkuId(userId, skuIds, null, CartItemStatusEnum.DELETE_BY_MANUAL.getValue());
         // 返回成功
-        return CommonResult.success(true);
+        return true;
     }
 
     @Override
-    public CommonResult<Boolean> deleteAll(Integer userId) {
+    public Boolean deleteAll(Integer userId) {
         return null;
     }
 
     @Override
-    public CommonResult<Integer> count(Integer userId) {
+    public Integer count(Integer userId) {
-        return CommonResult.success(cartMapper.selectQuantitySumByUserIdAndStatus(userId, CartItemStatusEnum.ENABLE.getValue()));
+        return cartMapper.selectQuantitySumByUserIdAndStatus(userId, CartItemStatusEnum.ENABLE.getValue());
     }
 
     @Override
-    public CommonResult<List<CartItemBO>> list(Integer userId, Boolean selected) {
+    public List<CartItemBO> list(Integer userId, Boolean selected) {
         List<CartItemDO> items = cartMapper.selectByUserIdAndStatusAndSelected(userId, CartItemStatusEnum.ENABLE.getValue(), selected);
-        return CommonResult.success(CartConvert.INSTANCE.convert(items));
+        return CartConvert.INSTANCE.convert(items);
     }
 
     @Override
-    public CommonResult<CalcOrderPriceBO> calcOrderPrice(CalcOrderPriceDTO calcOrderPriceDTO) {
+    public CalcOrderPriceBO calcOrderPrice(CalcOrderPriceDTO calcOrderPriceDTO) {
         // TODO 芋艿，补充一些表单校验。例如说，需要传入用户编号。
         // 校验商品都存在
         Map<Integer, CalcOrderPriceDTO.Item> calcOrderItemMap = calcOrderPriceDTO.getItems().stream()
                 .collect(Collectors.toMap(CalcOrderPriceDTO.Item::getSkuId, item -> item)); // KEY：skuId
         List<ProductSkuDetailBO> skus = productSpuService.getProductSkuDetailList(calcOrderItemMap.keySet());
         if (skus.size() != calcOrderPriceDTO.getItems().size()) {
-            return ServiceExceptionUtil.error(OrderErrorCodeEnum.ORDER_ITEM_SOME_NOT_EXISTS.getCode());
+            throw ServiceExceptionUtil.exception(OrderErrorCodeEnum.ORDER_ITEM_SOME_NOT_EXISTS.getCode());
         }
         // TODO 库存相关
         // 查询促销活动
@@ -172,11 +171,8 @@ public class CartServiceImpl implements CartService {
         calcOrderPriceBO.setItemGroups(itemGroups);
         // 4. 计算优惠劵
         if (calcOrderPriceDTO.getCouponCardId() != null) {
-            CommonResult<Integer> result = modifyPriceByCouponCard(calcOrderPriceDTO.getUserId(), calcOrderPriceDTO.getCouponCardId(), itemGroups);
+            Integer result = modifyPriceByCouponCard(calcOrderPriceDTO.getUserId(), calcOrderPriceDTO.getCouponCardId(), itemGroups);
-            if (result.isError()) {
+            calcOrderPriceBO.setCouponCardDiscountTotal(result);
-                return CommonResult.error(result);
-            }
-            calcOrderPriceBO.setCouponCardDiscountTotal(result.getData());
         }
         // 5. 计算最终的价格
         int buyTotal = 0;
@@ -191,31 +187,31 @@ public class CartServiceImpl implements CartService {
                 String.format("价格合计( %d - %d == %d )不正确", buyTotal, discountTotal, presentTotal));
         calcOrderPriceBO.setFee(new CalcOrderPriceBO.Fee(buyTotal, discountTotal, 0, presentTotal));
         // 返回
-        return CommonResult.success(calcOrderPriceBO);
+        return calcOrderPriceBO;
     }
 
     @Override
     @SuppressWarnings("Duplicates")
-    public CommonResult<CalcSkuPriceBO> calcSkuPrice(Integer skuId) {
+    public CalcSkuPriceBO calcSkuPrice(Integer skuId) {
         // 查询 SKU 是否合法
         ProductSkuBO sku = productSpuService.getProductSku(skuId);
         if (sku == null
                 || CommonStatusEnum.DISABLE.getValue().equals(sku.getStatus())) { // sku 被禁用
-            return ServiceExceptionUtil.error(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
+            throw ServiceExceptionUtil.exception(OrderErrorCodeEnum.CARD_ITEM_SKU_NOT_FOUND.getCode());
         }
         // 查询促销活动
         List<PromotionActivityBO> activityList = promotionActivityService.getPromotionActivityListBySpuId(sku.getSpuId(),
                 Arrays.asList(PromotionActivityStatusEnum.WAIT.getValue(), PromotionActivityStatusEnum.RUN.getValue()));
         if (activityList.isEmpty()) { // 如果无促销活动，则直接返回默认结果即可
-            return CommonResult.success(new CalcSkuPriceBO().setOriginalPrice(sku.getPrice()).setBuyPrice(sku.getPrice()));
+            return new CalcSkuPriceBO().setOriginalPrice(sku.getPrice()).setBuyPrice(sku.getPrice());
         }
         // 如果有促销活动，则开始做计算 TODO 芋艿，因为现在暂时只有限时折扣 + 满减送。所以写的比较简单先
         PromotionActivityBO fullPrivilege = findPromotionActivityByType(activityList, PromotionActivityTypeEnum.FULL_PRIVILEGE);
         PromotionActivityBO timeLimitedDiscount = findPromotionActivityByType(activityList, PromotionActivityTypeEnum.TIME_LIMITED_DISCOUNT);
         Integer presentPrice = calcSkuPriceByTimeLimitDiscount(sku, timeLimitedDiscount);
         // 返回结果
-        return CommonResult.success(new CalcSkuPriceBO().setFullPrivilege(fullPrivilege).setTimeLimitedDiscount(timeLimitedDiscount)
+        return new CalcSkuPriceBO().setFullPrivilege(fullPrivilege).setTimeLimitedDiscount(timeLimitedDiscount)
-                .setOriginalPrice(sku.getPrice()).setBuyPrice(presentPrice));
+                .setOriginalPrice(sku.getPrice()).setBuyPrice(presentPrice);
     }
 
     private List<CalcOrderPriceBO.Item> initCalcOrderPriceItems(List<ProductSkuDetailBO> skus,
@@ -306,14 +302,10 @@ public class CartServiceImpl implements CartService {
         return itemGroups;
     }
 
-    private CommonResult<Integer> modifyPriceByCouponCard(Integer userId, Integer couponCardId, List<CalcOrderPriceBO.ItemGroup> itemGroups) {
+    private Integer modifyPriceByCouponCard(Integer userId, Integer couponCardId, List<CalcOrderPriceBO.ItemGroup> itemGroups) {
         Assert.isTrue(couponCardId != null, "优惠劵编号不能为空");
         // 查询优惠劵
-        CommonResult<CouponCardDetailBO> couponCardResult = couponService.getCouponCardDetail(userId, couponCardId);
+        CouponCardDetailBO couponCard = couponService.getCouponCardDetail(userId, couponCardId);
-        if (couponCardResult.isError()) {
-            return CommonResult.error(couponCardResult);
-        }
-        CouponCardDetailBO couponCard = couponCardResult.getData();
         // 获得匹配的商品
         List<CalcOrderPriceBO.Item> items = new ArrayList<>();
         if (RangeTypeEnum.ALL.getValue().equals(couponCard.getRangeType())) {
@@ -347,7 +339,7 @@ public class CartServiceImpl implements CartService {
         // 判断是否符合条件
         int originalTotal = items.stream().mapToInt(CalcOrderPriceBO.Item::getPresentTotal).sum(); // 此处，指的是以优惠劵视角的原价
         if (originalTotal == 0 || originalTotal < couponCard.getPriceAvailable()) {
-            return ServiceExceptionUtil.error(PromotionErrorCodeEnum.COUPON_CARD_NOT_MATCH.getCode()); // TODO 芋艿，这种情况，会出现错误码的提示，无法格式化出来。另外，这块的最佳实践，找人讨论下。
+            throw ServiceExceptionUtil.exception(PromotionErrorCodeEnum.COUPON_CARD_NOT_MATCH.getCode()); // TODO 芋艿，这种情况，会出现错误码的提示，无法格式化出来。另外，这块的最佳实践，找人讨论下。
         }
         // 计算价格
         // 获得到优惠信息，进行价格计算
@@ -370,7 +362,7 @@ public class CartServiceImpl implements CartService {
         // 按比例，拆分 presentTotal
         splitDiscountPriceToItems(items, discountTotal, presentTotal);
         // 返回优惠金额
-        return CommonResult.success(originalTotal - presentTotal);
+        return originalTotal - presentTotal;
     }
 
     /**

order/order-service-impl/src/main/java/cn/iocoder/mall/order/biz/service/OrderReturnServiceImpl.java

@@ -141,7 +141,7 @@ public class OrderReturnServiceImpl implements OrderReturnService {
         );
     }
 
-    @Override
+//    @Override
     public CommonResult agree(Integer id) {
         OrderReturnDO orderReturnDO = orderReturnMapper.selectById(id);
         if (orderReturnDO == null) {

order/order-service-impl/src/main/java/cn/iocoder/mall/order/biz/service/OrderServiceImpl.java

@@ -224,11 +224,7 @@ public class OrderServiceImpl implements OrderService {
         }
 
         // 价格计算
-        CommonResult<CalcOrderPriceBO> calcOrderPriceResult = calcOrderPrice(productList, orderCreateDTO);
+        CalcOrderPriceBO calcOrderPrice = calcOrderPrice(productList, orderCreateDTO);
-        if (calcOrderPriceResult.isError()) {
-            return CommonResult.error(calcOrderPriceResult);
-        }
-        CalcOrderPriceBO calcOrderPrice = calcOrderPriceResult.getData();
 
         // 设置 orderItem
         Map<Integer, ProductSkuDetailBO> productSpuBOMap = productList
@@ -261,10 +257,7 @@ public class OrderServiceImpl implements OrderService {
 
         // 标记优惠劵已使用
         if (orderCreateDTO.getCouponCardId() != null) {
-            CommonResult<Boolean> useCouponCardResult = couponService.useCouponCard(userId, orderCreateDTO.getCouponCardId());
+            couponService.useCouponCard(userId, orderCreateDTO.getCouponCardId());
-            if (useCouponCardResult.isError()) {
-                return CommonResult.error(useCouponCardResult);
-            }
         }
 
         // TODO 芋艿，扣除库存
@@ -329,10 +322,7 @@ public class OrderServiceImpl implements OrderService {
         orderItemMapper.insert(orderItemDOList);
 
         // 创建预订单
-        CommonResult<PayTransactionBO> createPayTransactionResult = createPayTransaction(orderDO, orderItemDOList, orderCreateDTO.getIp());
+        createPayTransaction(orderDO, orderItemDOList, orderCreateDTO.getIp());
-        if (calcOrderPriceResult.isError()) {
-            return CommonResult.error(calcOrderPriceResult);
-        }
 
 //        if (commonResult.isError()) {
 //            //手动开启事务回滚
@@ -349,7 +339,7 @@ public class OrderServiceImpl implements OrderService {
         );
     }
 
-    private CommonResult<CalcOrderPriceBO> calcOrderPrice(List<ProductSkuDetailBO> skus, OrderCreateDTO orderCreateDTO) {
+    private CalcOrderPriceBO calcOrderPrice(List<ProductSkuDetailBO> skus, OrderCreateDTO orderCreateDTO) {
         // 创建计算的 DTO
         CalcOrderPriceDTO calcOrderPriceDTO = new CalcOrderPriceDTO()
                 .setUserId(orderCreateDTO.getUserId())