添加支付限流功能

src/main/java/com/sqx/modules/app/service/UserMoneyService.java

@@ -38,6 +38,7 @@ public interface UserMoneyService extends IService<UserMoney> {
      */
     UserMoneyDetails updateUserMoney(UpdateMoneyBO updateMoneyBO);
 
+    void updateNewPayUserMoney(UpdateMoneyBO updateMoneyBO) throws Exception;
     /**
      * 商户分账
      * @param shopId 商铺id

src/main/java/com/sqx/modules/app/service/impl/UserMoneyServiceImpl.java

@@ -266,6 +266,50 @@ public class UserMoneyServiceImpl extends ServiceImpl<UserMoneyDao, UserMoney> i
     }
 
     @Override
+    public void updateNewPayUserMoney(UpdateMoneyBO updateMoneyBO) throws Exception {
+        Long userId = updateMoneyBO.getUserId();
+        UserMoney userMoney = getByUserId(userId);
+        BigDecimal changeAmount = updateMoneyBO.getAmount();
+        Integer changeType = updateMoneyBO.getType();
+        if (changeType == 2) {
+            if (userMoney.getMoney().compareTo(changeAmount) <= 0) {
+                throw new SqxException("用户钱包余额不足,扣减失败!");
+            }
+        }
+
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+        // 新增明细
+        UserMoneyDetails userMoneyDetails = new UserMoneyDetails();
+        userMoneyDetails.setUserId(userId);
+        userMoneyDetails.setTitle(updateMoneyBO.getTitle());
+        userMoneyDetails.setType(changeType);
+        userMoneyDetails.setClassify(3);
+        userMoneyDetails.setState(2);
+        userMoneyDetails.setMoney(changeAmount);
+        String changeTypeFlag = changeType == 1 ? "新增" : "减少";
+        userMoneyDetails.setContent(changeTypeFlag + ":" + changeAmount +"元");
+        userMoneyDetails.setRemark(updateMoneyBO.getRemark());
+        userMoneyDetails.setCreateTime(sdf.format(new Date()));
+
+        updateOrInsertData(updateMoneyBO.getType(), userId, changeAmount.doubleValue(),userMoneyDetails);
+
+    }
+
+    @Transactional(rollbackFor = {Exception.class})
+    public void updateOrInsertData(Integer type,Long userId, double changeAmount,UserMoneyDetails userMoneyDetails) throws Exception {
+        try{
+            // 修改总金额
+            baseMapper.updateMayMoney(type,userId,changeAmount);
+            userMoneyDetailsDao.insert(userMoneyDetails);
+        }catch (Exception e){
+            System.out.println("修改总金额失败错误信息：" + e.getMessage());
+            throw new Exception("修改总金额失败！");
+        }
+
+    }
+
+    @Override
     @Transactional(propagation = Propagation.SUPPORTS)
     public UserMoneyDetails updateUserMoney(UpdateMoneyBO updateMoneyBO) {
         Long userId = updateMoneyBO.getUserId();

src/main/java/com/sqx/modules/common/service/CommonInfoService.java

@@ -40,4 +40,6 @@ public interface CommonInfoService {
      */
     Result findByTypeAndCondition(String condition);
 
+    boolean limit(String key, int limit, int expire);
+
 }

src/main/java/com/sqx/modules/common/service/impl/CommonInfoServiceImpl.java

@@ -9,10 +9,13 @@ import com.sqx.modules.common.dao.CommonInfoDao;
 import com.sqx.modules.common.entity.CommonInfo;
 import com.sqx.modules.common.service.CommonInfoService;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.redisson.api.RAtomicLong;
 import org.springframework.stereotype.Service;
 
 import java.text.SimpleDateFormat;
 import java.util.Date;
+import java.util.concurrent.TimeUnit;
 
 /**
  * @author fang
@@ -20,6 +23,7 @@ import java.util.Date;
  */
 @Service
 @RequiredArgsConstructor
+@Slf4j
 public class CommonInfoServiceImpl extends ServiceImpl<CommonInfoDao, CommonInfo> implements CommonInfoService {
 
     private final CommonInfoDao commonInfoDao;
@@ -77,5 +81,48 @@ public class CommonInfoServiceImpl extends ServiceImpl<CommonInfoDao, CommonInfo
         return Result.success().put("data",commonInfoDao.findByCondition(condition));
     }
 
+    /**
+     * 限流
+     * @param key 限流键
+     * @param limit 限流阈值（每秒允许的请求数）
+     * @param expire 过期时间（秒）
+     * @return 是否允许通过
+     */
+    @Override
+    public boolean limit(String key, int limit, int expire) {
+        try {
+            log.info("1");
+            // 生成Redis键
+            String redisKey = "rate:limit:" + key;
+            log.info("2");
+            // 获取当前令牌数
+            Object currentValue = redisUtils.get(redisKey);
+            log.info("3");
+            int current = currentValue == null ? 0 : Integer.parseInt(currentValue.toString());
+            log.info("4");
+            if (current < limit) {
+                log.info("5");
+                // 令牌桶未满，允许通过，令牌数+1
+                Long newValue = redisUtils.increment(redisKey);// 自增并返回新值
+                log.info("6");
+                // 设置过期时间（第一次设置）
+                if (current == 0) {
+                    log.info("7");
+                    // 给 key = "order:123" 设置 300 秒过期
+                    redisUtils.expire(redisKey,2);
+                }
+                log.info("8");
+                return true;
+            } else {
+                // 令牌桶已满，拒绝通过
+                log.info("接口限流，key: {}, current: {}, limit: {}", key, current, limit);
+                return false;
+            }
+        } catch (Exception e) {
+            log.error("限流处理异常：{}", e);
+            // 异常时默认允许通过，避免影响正常业务
+            return true;
+        }
+    }
 
 }

src/main/java/com/sqx/modules/member/service/VipService.java

@@ -20,6 +20,10 @@ public interface VipService {
       */
     void paySuccess(PayDetails payDetails);
 
+    void afterNewPaySuccess(Long userId) throws Exception;
+
+    void newPaySuccess(PayDetails payDetails) throws Exception;
+
      /**
       * 余额购买vip
       * @param userId 用户id

src/main/java/com/sqx/modules/member/service/impl/VipServiceImpl.java

@@ -83,6 +83,58 @@ public class VipServiceImpl implements VipService {
     }
 
     @Override
+    public void newPaySuccess(PayDetails payDetails) throws Exception {
+        Long userId = payDetails.getUserId();
+        UserEntity user = userService.getById(userId);
+        VipPromoRecordDTO recordDTO = VipPromoRecordDTO.builder()
+                .userId(userId)
+                .userName(user.getNickName())
+                .userPhone(user.getPhone())
+                .payType("1")
+                .promoCode(payDetails.getExtra())
+                .payAmount(payDetails.getMoney())
+                .payRelId(payDetails.getOrderId())
+                .build();
+        vipPromoRecordService.add(recordDTO);
+
+        // 更新用户为会员
+        afterNewPaySuccess(payDetails.getUserId());
+    }
+
+
+    @Transactional(rollbackFor = {Exception.class})
+    public void afterNewPaySuccess(Long userId) throws Exception {
+        // 会员期限（天）
+        CommonInfo vipExpirationDays = commonInfoService.findOne(314);
+        Integer vipExpirationDaysValue = Integer.valueOf(vipExpirationDays.getValue());
+
+        // 会员赠送红包数量
+        CommonInfo vipRedPacketNum = commonInfoService.findOne(315);
+
+        // 会员赠送红包金额
+        CommonInfo vipRedPacketMoney = commonInfoService.findOne(316);
+
+        // 会员失效时间
+        String expirationTime = VipExpirationUtil.getFutureTimeWithDays(vipExpirationDaysValue);
+
+        try{
+            // 更新用户为会员
+        userService.updateUserToVip(userId, expirationTime);
+
+            // 新增会员专属优惠券
+            for(int i = 0; i<Integer.valueOf(vipRedPacketNum.getValue()); i++){
+                tbCouponUserService.addAfterVipBuySuccess(userId, new BigDecimal(vipRedPacketMoney.getValue()), vipExpirationDays.getValue(), expirationTime);
+            }
+        }catch (Exception e){
+            System.out.println("会员操作失败错误信息：" + e.getMessage());
+            throw new Exception("会员操作失败！");
+        }
+
+
+    }
+
+
+    @Override
     @Transactional(rollbackFor = Exception.class)
     public void paySuccess(PayDetails payDetails) {
         Long userId = payDetails.getUserId();
@@ -137,6 +189,9 @@ public class VipServiceImpl implements VipService {
         afterPaySuccess(userId);
     }
 
+
+
+
     private void beforePay(UserEntity user, String promoCode) {
         if(ObjectUtil.isNotNull(user.getIsVip()) && user.getIsVip() == 1 && VipExpirationUtil.isVipValid(user.getVipExpirationTime())) {
             throw new SqxException("已经是会员，不能重复购买！");

src/main/java/com/sqx/modules/order/controller/app/AppOrderController.java

@@ -2,21 +2,27 @@ package com.sqx.modules.order.controller.app;
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.util.ObjectUtil;
+import com.google.common.util.concurrent.RateLimiter;
 import com.sqx.common.exception.SqxException;
 import com.sqx.common.utils.PageUtils;
 import com.sqx.common.utils.Result;
 import com.sqx.modules.app.annotation.Login;
+import com.sqx.modules.common.service.CommonInfoService;
+import com.sqx.modules.common.service.impl.CommonInfoServiceImpl;
 import com.sqx.modules.order.controller.query.GoodsSkuQuery;
 import com.sqx.modules.order.entity.Evaluate;
 import com.sqx.modules.order.entity.TbOrder;
 import com.sqx.modules.order.service.AppOrderService;
 import com.sqx.modules.order.service.EvaluateService;
+import com.sqx.modules.order.service.impl.AppAppOrderServiceImpl;
 import com.sqx.modules.pay.dto.PayOrderDTO;
 import com.sqx.modules.pay.vo.PayTransactionsVO;
+import com.sqx.modules.utils.RateLimiters;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestAttribute;
@@ -37,6 +43,9 @@ public class AppOrderController {
     private final AppOrderService appOrderService;
     private final EvaluateService evaluateService;
 
+    @Autowired
+    CommonInfoService commonInfoService;
+
     @Login
     @ApiOperation("生成订单(未结算状态)")
     @PostMapping(value = "/insertOrder")
@@ -62,7 +71,11 @@ public class AppOrderController {
     @ApiOperation("直接购买单个商品")
     @PostMapping(value = "buyGoods")
     public Result buyGoods(@RequestAttribute Long userId, Long shopId, Long goodsId, Integer num, Long skuId, String skuMessage, Integer orderType){
-
+        boolean allow = commonInfoService.limit("buyGoods",100,1);
+        if (!allow) {
+            log.info("用餐高峰期，请刷新重试！");
+            return Result.error("用餐高峰期，请刷新重试！");
+        }
         return appOrderService.buyGoods(userId, shopId, goodsId, num, skuId, skuMessage, orderType);
     }
 
@@ -279,9 +292,14 @@ public class AppOrderController {
     }
 
     @Login
-    @ApiOperation("获取支付参数")
+    @ApiOperation("获取支付参数，新支付")
     @GetMapping(value = "get-pay-param")
     public Result getPayParam(@RequestAttribute("userId") Long userId, @Valid PayOrderDTO payOrderDTO){
+        boolean allow = commonInfoService.limit("getPayParam",100,1);
+        if (!allow) {
+            log.info("用餐高峰期，请刷新重试！");
+            return Result.error("用餐高峰期，请刷新重试！");
+        }
         PayTransactionsVO payParamVO = appOrderService.getTransactionsParam(userId, payOrderDTO);
         return Result.success(BeanUtil.beanToMap(payParamVO, false, true));
     }
@@ -298,4 +316,21 @@ public class AppOrderController {
     public void exportGoodsSkuSalesCount(@Valid GoodsSkuQuery query){
         appOrderService.exportGoodsSkuSalesCount(query);
     }
+
+    Integer i=0;
+
+    @GetMapping(value = "testlimit")
+    @ApiOperation("导出商品sku销售数量")
+    public Result exportGoodsSkuSalesCount(){
+        i++;
+
+        // 限流：每秒最多100个请求
+        boolean allow = commonInfoService.limit("testlimit", 100, 1);
+        if (!allow) {
+            log.info("高峰期，请稍后重试" + i);
+            return Result.error("高峰期，请稍后重试!");
+        }
+        log.info("正常操作" + i);
+        return Result.success();
+    }
 }

src/main/java/com/sqx/modules/order/service/impl/AppAppOrderServiceImpl.java

@@ -19,12 +19,7 @@ import com.ekyong.www.pay.pay.qrcode.bean.QrcodeQueryResponseBean;
 import com.sqx.common.constant.RedisKey;
 import com.sqx.common.exception.SqxException;
 import com.sqx.common.sms.SmsSendResult;
-import com.sqx.common.utils.Constant;
-import com.sqx.common.utils.DateUtils;
-import com.sqx.common.utils.DistanceUtil;
-import com.sqx.common.utils.MyGlobalThreadPool;
-import com.sqx.common.utils.PageUtils;
-import com.sqx.common.utils.Result;
+import com.sqx.common.utils.*;
 import com.sqx.datasource.annotation.DataSource;
 import com.sqx.modules.activity.entity.ActivityPartRecord;
 import com.sqx.modules.activity.service.ActivityPartRecordService;
@@ -110,6 +105,7 @@ import com.sqx.modules.utils.fieYun.FeiYunUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang.StringUtils;
 import org.apache.shiro.SecurityUtils;
+import org.redisson.api.RAtomicLong;
 import org.redisson.api.RLock;
 import org.redisson.api.RedissonClient;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -3162,4 +3158,5 @@ public class AppAppOrderServiceImpl extends ServiceImpl<AppOrderDao, TbOrder> im
 
         log.info("preOrder==>[{}]，订单参与会员优惠，优惠后金额为：{}元", order.getOrderId(), payMoney);
     }
+
 }

src/main/java/com/sqx/modules/pay/controller/app/ApiWeiXinPayController.java

@@ -3,6 +3,7 @@ package com.sqx.modules.pay.controller.app;
 import com.sqx.common.utils.RedisUtils;
 import com.sqx.common.utils.Result;
 import com.sqx.modules.app.annotation.Login;
+import com.sqx.modules.common.service.CommonInfoService;
 import com.sqx.modules.pay.dto.PayOrderDTO;
 import com.sqx.modules.pay.dao.PayDetailsDao;
 import com.sqx.modules.pay.service.WxService;
@@ -40,6 +41,8 @@ public class ApiWeiXinPayController {
     @Autowired
     private PayDetailsDao payDetailsDao;
 
+    @Autowired
+    CommonInfoService commonInfoService;
 
     @Login
     @ApiOperation("微信支付宝充值钱包")
@@ -49,9 +52,14 @@ public class ApiWeiXinPayController {
     }
 
     @Login
-    @ApiOperation("微信支付宝支付订单")
+    @ApiOperation("微信支付宝支付订单，旧支付")
     @PostMapping("/wxPayJsApiOrder")
     public Result wxPayJsApiOrder(@RequestAttribute("userId") Long userId, @Valid PayOrderDTO payOrderDTO) throws Exception {
+        boolean allow = commonInfoService.limit("wxPayJsApiOrder",100,1);
+        if (!allow) {
+            log.info("用餐高峰期，请刷新重试！");
+            return Result.error("用餐高峰期，请刷新重试！");
+        }
         return wxService.payOrder(userId, payOrderDTO);
     }
 
@@ -59,7 +67,11 @@ public class ApiWeiXinPayController {
     @ApiOperation("余额支付订单")
     @PostMapping(value = "balanceOrder")
     public Result balanceOrder(@RequestAttribute Long userId, @Valid PayOrderDTO payOrderDTO){
-
+        boolean allow = commonInfoService.limit("balanceOrder",100,1);
+        if (!allow) {
+            log.info("用餐高峰期，请刷新重试！");
+            return Result.error("用餐高峰期，请刷新重试！");
+        }
         return wxService.balanceOrder(userId, payOrderDTO);
     }
 

src/main/java/com/sqx/modules/pay/service/impl/NewPayServiceImpl.java

@@ -19,6 +19,7 @@ import com.sqx.common.utils.SpringContextUtils;
 import com.sqx.modules.app.bo.UpdateMoneyBO;
 import com.sqx.modules.app.service.UserMoneyService;
 import com.sqx.modules.common.service.CommonInfoService;
+import com.sqx.modules.goods.entity.GoodsShop;
 import com.sqx.modules.goods.service.GoodsShopService;
 import com.sqx.modules.member.service.VipService;
 import com.sqx.modules.order.entity.TbOrder;
@@ -34,6 +35,7 @@ import com.sqx.modules.pay.service.PayDetailsService;
 import com.sqx.modules.pay.vo.WechatTransactionsParamVO;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -189,9 +191,7 @@ public class NewPayServiceImpl implements NewPayService {
             throw new SqxException("分账，" + e.getMessage());
         }
     }
-
     @Override
-    @Transactional
     public String wechatPayNotify(String reqJsonData) {
         try {
             String decode = URLDecoder.decode(reqJsonData, "GBK");
@@ -228,15 +228,25 @@ public class NewPayServiceImpl implements NewPayService {
                 payDetails.setRemark("RHT PAY SUCCESS");
                 payDetailsService.updateDetail(payDetails);
 
-                PaySceneEnum payScene = PaySceneEnum.getBySceneCode(payDetails.getClassify());
-                switch (payScene) {
-                    case ORDER_PAY: handleTakeoutOrderPaySuccess(payDetails); break;
-                    case BALANCE_RECHARGE: handleBalanceRechargePaySuccess(payDetails); break;
-                    case BOND_PAY: handleBondPaySuccess(payDetails); break;
-                    case VIP_PAY: handleVipPaySuccess(payDetails); break;
-                    default:
-                        log.error("监测到不支持的支付成功场景，支付订单信息：{}", JSONUtil.toJsonStr(payDetails));
-                }
+                // 后续业务走异步处理
+                PayDetails finalPayDetails = payDetails;
+                String finalOrderNo = orderNo;
+                com.sqx.common.utils.MyGlobalThreadPool.execute(() -> {
+                    try {
+                        PaySceneEnum payScene = PaySceneEnum.getBySceneCode(finalPayDetails.getClassify());
+                        switch (payScene) {
+                            case ORDER_PAY: handleTakeoutOrderPaySuccess(finalPayDetails); break;
+                            case BALANCE_RECHARGE: handleBalanceRechargePaySuccess(finalPayDetails); break;
+                            case BOND_PAY: handleBondPaySuccess(finalPayDetails); break;
+                            case VIP_PAY: handleVipPaySuccess(finalPayDetails); break;
+                            default:
+                                log.error("监测到不支持的支付成功场景，支付订单信息：{}", JSONUtil.toJsonStr(finalPayDetails));
+                        }
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                        log.error("异步处理支付成功后续业务异常：{}", e.getMessage());
+                    }
+                });
             }
             return "success";
         } catch (Exception e) {
@@ -256,16 +266,16 @@ public class NewPayServiceImpl implements NewPayService {
      * 处理vip购买成功通知
      * @param payDetails
      */
-    private void handleVipPaySuccess(PayDetails payDetails) {
+    private void handleVipPaySuccess(PayDetails payDetails) throws Exception {
         VipService vipService = SpringContextUtils.getBean(VipService.class);
-        vipService.paySuccess(payDetails);
+        vipService.newPaySuccess(payDetails);
     }
 
     /**
      * 处理充值成功通知
      * @param payDetails
      */
-    private void handleBalanceRechargePaySuccess(PayDetails payDetails) {
+    private void handleBalanceRechargePaySuccess(PayDetails payDetails) throws Exception {
         UpdateMoneyBO updateMoneyBO = UpdateMoneyBO.builder()
                 .userId(payDetails.getUserId())
                 .type(1)
@@ -274,7 +284,7 @@ public class NewPayServiceImpl implements NewPayService {
                 .title("充值入账")
                 .remark(payDetails.getOrderId())
                 .build();
-        userMoneyService.updateUserMoney(updateMoneyBO);
+        userMoneyService.updateNewPayUserMoney(updateMoneyBO);
     }
 
     /**

src/main/java/com/sqx/modules/utils/RateLimiters.java

@@ -0,0 +1,69 @@
+package com.sqx.modules.utils;
+
+import lombok.extern.slf4j.Slf4j;
+import org.redisson.api.RAtomicLong;
+import org.redisson.api.RedissonClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Service;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 基于Redis的令牌桶限流工具类
+ */
+@Slf4j
+@Component
+public class RateLimiters {
+
+    @Resource
+    private RedissonClient redissonClient;
+
+    /**
+     * 限流
+     * @param key 限流键
+     * @param limit 限流阈值（每秒允许的请求数）
+     * @param expire 过期时间（秒）
+     * @return 是否允许通过
+     */
+    public boolean limit(String key, int limit, int expire) {
+        try {
+            log.info("1");
+            // 生成Redis键
+            String redisKey = "rate:limit:" + key;
+            log.info("2");
+            // 获取当前令牌数
+            Object currentValue = redissonClient.getBucket(redisKey).get();
+            log.info("3");
+            int current = currentValue == null ? 0 : Integer.parseInt(currentValue.toString());
+            log.info("4");
+            if (current < limit) {
+                log.info("5");
+                // 令牌桶未满，允许通过，令牌数+1
+                RAtomicLong atomicLong = redissonClient.getAtomicLong(redisKey);
+                long newValue = atomicLong.incrementAndGet();  // 自增并返回新值
+                log.info("6");
+                // 设置过期时间（第一次设置）
+                if (current == 0) {
+                    log.info("7");
+                    // 给 key = "order:123" 设置 300 秒过期
+                    redissonClient.getBucket(redisKey).expire(expire, TimeUnit.SECONDS);
+                }
+                log.info("8");
+                return true;
+            } else {
+                // 令牌桶已满，拒绝通过
+                log.info("接口限流，key: {}, current: {}, limit: {}", key, current, limit);
+                return false;
+            }
+        } catch (Exception e) {
+            log.error("限流处理异常：{}", e);
+            // 异常时默认允许通过，避免影响正常业务
+            return true;
+        }
+    }
+}

src/main/java/com/sqx/scheduler/order/OrderScheduler.java

@@ -237,7 +237,7 @@ public class OrderScheduler {
 
             log.info("超时订单自动取消任务开始运行");
             // 加5分钟在前端强制取消前执行 ??
-            long time = new Date().getTime() + 5*60*1000;
+            long time = new Date().getTime() + 10*60*1000;
             List<TbOrder> orderList = orderService.changeTimeOutOrder(time);
 
             if (orderList.size() == 0) {
@@ -283,8 +283,13 @@ public class OrderScheduler {
                         tbOrder.setPayType(1);
                         orderService.updateOrderAfterPaySuccess(tbOrder,payTime);
                     } else {
-                        tbOrder.setStatus(5);
-                        orders.add(tbOrder);
+//                        判断当前订单是否到超时时间，到了则取消
+                        Long timeOut = tbOrder.getTimeOut();
+                        if (new Date().getTime()>=timeOut) {
+                            tbOrder.setStatus(5);
+                            orders.add(tbOrder);
+                        }
+
                     }
                 } catch (Exception e) {
                     log.error("超时任务处理订单【{}】查询支付结果失败，失败原因：{}", orderNumber, e.getMessage());