修复退款校验判断问题

assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/enums/NewOrderType.java

-//package com.freemud.sdk.api.assortment.order.enums;
-//
-//import java.util.ArrayList;
-//import java.util.List;
-//
-///**
-// * All rights Reserved, Designed By www.freemud.cn
-// *
-// * @version V1.0
-// * @Title: NewOldOrderType
-// * @Package com.freemud.sdk.api.assortment.enums
-// * @Description:
-// * @author: ping.wu
-// * @date: 2019/4/18 17:28
-// * @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
-// * 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
-// */
-//public enum NewOrderType {
-//
-//    GENERAL_DINE_IN(1, "店内自取实时-1常规堂食"),
-//    RESERVED_DINE_IN(2, "店内自取预约-2预约堂食"),
-//    GENERAL_EXPRESS(3, "店外快递实时-3常规外送"),
-//    RESERVED_EXPRESS(4, "店外快递预约-4预约外送"),
-//    GENERAL_SELF_PICKUP(5, "店外自取实时-5常规自取"),
-//    RESERVED_SELF_PICKUP(6, "店外自取预约-6预约自取")
-//    ;
-//
-//    private Integer code;
-//    private String desc;
-//
-//    NewOrderType(Integer code, String desc) {
-//        this.code = code;
-//        this.desc = desc;
-//    }
-//
-//    public static List<Integer> getAllCodes() {
-//        List<Integer> list = new ArrayList<>();
-//        for (NewOrderType type : values()) {
-//            list.add(type.getCode());
-//        }
-//        return list;
-//    }
-//
-//
-//    public static NewOrderType getByCode(Integer code) {
-//        if (code == null) {
-//            return null;
-//        }
-//        for (NewOrderType newOrderType : values()) {
-//            if (newOrderType.getCode().equals(code)) {
-//                return newOrderType;
-//            }
-//        }
-//        return null;
-//    }
-//
-//    public Integer getCode() {
-//        return code;
-//    }
-//
-//    public String getDesc() {
-//        return desc;
-//    }
-//
-//}
+package com.freemud.sdk.api.assortment.order.enums;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * All rights Reserved, Designed By www.freemud.cn
+ *
+ * @version V1.0
+ * @Title: NewOldOrderType
+ * @Package com.freemud.sdk.api.assortment.enums
+ * @Description:
+ * @author: ping.wu
+ * @date: 2019/4/18 17:28
+ * @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
+ * 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目
+ */
+public enum NewOrderType {
+
+    GENERAL_DINE_IN(1, "店内自取实时-1常规堂食"),
+    RESERVED_DINE_IN(2, "店内自取预约-2预约堂食"),
+    GENERAL_EXPRESS(3, "店外快递实时-3常规外送"),
+    RESERVED_EXPRESS(4, "店外快递预约-4预约外送"),
+    GENERAL_SELF_PICKUP(5, "店外自取实时-5常规自取"),
+    RESERVED_SELF_PICKUP(6, "店外自取预约-6预约自取")
+    ;
+
+    private final Integer code;
+    private final String desc;
+
+    NewOrderType(Integer code, String desc) {
+        this.code = code;
+        this.desc = desc;
+    }
+
+    public static List<Integer> getAllCodes() {
+        List<Integer> list = new ArrayList<>();
+        for (NewOrderType type : values()) {
+            list.add(type.getCode());
+        }
+        return list;
+    }
+
+
+    public static NewOrderType getByCode(Integer code) {
+        if (code == null) {
+            return null;
+        }
+        for (NewOrderType newOrderType : values()) {
+            if (newOrderType.getCode().equals(code)) {
+                return newOrderType;
+            }
+        }
+        return null;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+
+    public static boolean isDelivery(Integer orderType) {
+        if (orderType == null) {
+            return false;
+        }
+        return orderType.equals(NewOrderType.GENERAL_EXPRESS.getCode())
+                || orderType.equals(NewOrderType.RESERVED_EXPRESS.getCode());
+    }
+
+}

order-application-service/src/main/java/cn/freemud/service/RefundService.java

@@ -276,7 +276,7 @@ public class RefundService {
      */
     private void refundOrder(OrderInfoReqs order, String reason, String remark, Boolean isRefundDeliveryFee, Byte refundMode) {
         int state = PayRefundStatus.SUCCESS.getCode();
-        if (order.getActualPayAmount().longValue() > 0) {
+        if (order.getSettlementAmount().longValue() > 0) {
             PayRefundResponse refundResponse = paymentHandle.getCommonPayRefundResponse(order, reason);
             state = refundResponse.getPayRefundStatus().getCode();
         }

order-management/src/main/java/cn/freemud/management/service/handle/OrderVerifyHandle.java

@@ -5,26 +5,23 @@ import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
 import cn.freemud.management.entities.dto.response.order.OrderManagerResponse;
 import cn.freemud.management.enums.DeliveryStatus;
 import cn.freemud.management.enums.OperateType;
-import cn.freemud.management.enums.RefundStatus;
 import cn.freemud.management.enums.ResponseResult;
 import cn.freemud.management.util.ResponseUtil;
 import cn.freemud.redis.RedisCache;
 import com.alibaba.fastjson.JSON;
-import com.freemud.api.assortment.datamanager.manager.cache.CacheOpenPlatformPartnerWxappConfigManager;
+import com.alibaba.fastjson.JSONObject;
 import com.freemud.application.sdk.api.ordercenter.entities.v1.OrderBeanV1;
 import com.freemud.application.sdk.api.ordercenter.entities.v1.RefundBeanV1;
 import com.freemud.application.sdk.api.ordercenter.enums.*;
 import com.freemud.application.sdk.api.ordercenter.enums.orderv1.OrderSourceV1;
 import com.freemud.application.sdk.api.ordercenter.enums.orderv1.OrderStatusV1;
 import com.freemud.application.sdk.api.ordercenter.enums.orderv1.OrderTypeV1;
-import com.freemud.application.sdk.api.ordercenter.enums.orderv1.RefundStatusV1;
 import com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto;
 import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderInfoReqs;
 import com.freemud.sdk.api.assortment.message.enums.OrderType;
-import com.freemud.sdk.api.assortment.order.adapter.OrderSdkAdapter;
 import com.freemud.sdk.api.assortment.order.constant.OrderRedisKeyConstant;
 import com.freemud.sdk.api.assortment.order.entities.OrderRefundConfigEntity;
-import com.freemud.sdk.api.assortment.order.service.OrderCenterSdkService;
+import com.freemud.sdk.api.assortment.order.enums.NewOrderType;
 import com.google.common.collect.Lists;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang.ObjectUtils;
@@ -61,30 +58,14 @@ public class OrderVerifyHandle {
      * 允许退款
      */
     private static final String ALLOW_REFUND = "1";
-    /**
-     * svc储值卡支付，可用于判断订单是否用储值卡支付
-     */
-    private static final String PAY_CODE_10102 = "10102";
-
-    @Autowired
-    private CacheOpenPlatformPartnerWxappConfigManager cacheOpenPlatformPartnerWxappConfigManager;
 
     @Autowired
-    private OrderSdkAdapter orderSdkAdapter;
-    @Autowired
-    private OrderCenterSdkService orderCenterSdkService;
-    @Autowired
-    private DeliveryHandle deliveryHandle;
-    @Autowired
     private RedisCache redisCache;
 
-    @Value("${delivery.support.ordersource}")
-    private String supportOrderSource;
     @Value("${mccafe.partner.id}")
     private String macCafePartnerId;
 
     private static final String THIRD = "third";
-    private static final String delivery_type_self = "self";
     /**
      * 接单校验
      *
@@ -367,20 +348,9 @@ public class OrderVerifyHandle {
             }
             return ResponseUtil.success();
         }
-        //订单是否支持退款
-        boolean isCanRefund = false;
         //订单
         boolean isRefundDeliveryFee=false;
-        //saas渠道订单，已完成的订单不能操作, 商户配置已完成订单可退款可退款
-//        if (ObjectUtils.equals(orderBean.getSource(), OrderSourceV1.SAAS.getCode())) {
-//            isCanRefund = getRefundConfig(orderBean);
-//            if (!isCanRefund) {
-//                return ResponseUtil.error(ResponseResult.ORDER_HAD_AFFIRM_CAN_NOT_REFUND);
-//            }
-//        }
-//        if (isCanRefund) {
         orderBean.setAmount(getRefundAmount(orderBean,isRefundDeliveryFee).longValue());
-//        }
         return ResponseUtil.success();
     }
 
@@ -418,29 +388,6 @@ public class OrderVerifyHandle {
     }
 
     /**
-     * 麦咖啡同意退款
-     *
-     * @param orderBean
-     * @param request
-     * @return
-     */
-    public BaseResponse orderAgreeRefundMCCafe(OrderBeanV1 orderBean, OrderManagerRequest request) {
-        //已取消的订单不能操作
-        if (ObjectUtils.equals(OrderStatusV1.CANCEL.getV2Code(), orderBean.getStatusV2())) {
-            return ResponseUtil.error(ResponseResult.ORDER_HAS_CANCELED);
-        }
-        for (RefundBeanV1 refundBean : orderBean.getRefundList()) {
-            if(RefundStatusV1.APPLY_REFUND.getCodeV1().equals(refundBean.getStatus())) {
-                return ResponseUtil.success();
-            }
-            if(RefundStatusV1.COMPLETE_REFUND.getCodeV1().equals(refundBean.getStatus())) {
-                return ResponseUtil.error(ResponseResult.AGREE_REFUND_ORDER_FAIL.getCode(), "订单已经退款完成，不能重复申请");
-            }
-        }
-        return ResponseUtil.success();
-    }
-
-    /**
      * 拒绝退款
      * @param orderBean
      * @param request
@@ -511,56 +458,7 @@ public class OrderVerifyHandle {
         return ResponseUtil.success();
     }
 
-    /**
-     * 拒绝退款
-     * @param orderBean
-     * @param request
-     * @return
-     */
-    public BaseResponse mcCafeOrderRejectRefund(OrderBeanV1 orderBean, OrderManagerRequest request) {
-        //判断当前订单是否发起退款
-        if (orderBean.getHasRefund() == null || !orderBean.getHasRefund()) {
-            return ResponseUtil.error(ResponseResult.ORDER_REFUND_NOT_APPLY);
-        }
-
-        if(CollectionUtils.isEmpty(orderBean.getRefundList())) {
-            return ResponseUtil.error(ResponseResult.ORDER_REFUND_NOT_APPLY);
-        }
-
-        for (RefundBeanV1 refundBean : orderBean.getRefundList()) {
-            if (ObjectUtils.equals(refundBean.getStatus(), RefundStatus.COMPLETE_REFUND.getCode())) {
-                return ResponseUtil.error(ResponseResult.ORDER_REJECT_REFUND_REPETITION);
-            }
-
-            if (OrderStatusV1.CANCEL.getV2Code().equals(orderBean.getStatusV2())) {
-                return ResponseUtil.error(ResponseResult.ORDER_REJECT_REFUND_STATUS_END);
-            }
-
-            if (ObjectUtils.equals(refundBean.getStatus(), RefundStatus.APPLY_REFUND.getCode())) {
-                break;
-            }
-        }
-
-        return ResponseUtil.success();
-    }
 
-    /**
-     * 通用校验
-     *
-     * @param orderBean
-     * @param request
-     * @return
-     */
-    private BaseResponse commonVerify(OrderBeanV1 orderBean, OrderManagerRequest request) {
-        if (ObjectUtils.notEqual(orderBean.getCompanyId(), request.getPartnerId())) {
-            return ResponseUtil.error(ResponseResult.ORDER_PARTNER_ID_NOT_MATCTH, getOrderManagerResponse(orderBean));
-        }
-        //开放平台不传入门店
-        if (ObjectUtils.notEqual(request.getOperator(), OperateClient.OPEN_PLATFORM.getOpName()) && ObjectUtils.notEqual(orderBean.getShopId(), request.getStoreId())) {
-            return ResponseUtil.error(ResponseResult.ORDER_STORE_ID_NOT_MATCTH, getOrderManagerResponse(orderBean));
-        }
-        return ResponseUtil.success();
-    }
 
     /**
      * 是否是外卖
@@ -587,19 +485,65 @@ public class OrderVerifyHandle {
      *
      * @return true=可同意退款
      */
-    public boolean getRefundConfig(OrderBeanV1 order) {
-        return getRefundConfig(order.getCompanyId(), order.getOrderType(), order.getBizType(),
-                (int)order.getMarketingType(), order.getStatusV2(), order.getExtInfo());
+    @Deprecated
+    public boolean getRefundConfig(OrderBeanV1 data) {
+        // [华莱士20210410] 微商城订单判断
+        if(Objects.equals(BizTypeEnum.MALL.getBizType(),data.getBizType())){
+            // 除 未支付 拒单 和 取消外，其他可退款
+            return Stream.of(OrderStatusV1.WAIT_PAY,OrderStatusV1.CANCEL).noneMatch(s -> Objects.equals(data.getStatusV2(),s.getV2Code()));
         }
+        com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto extInfo = null;
+        JSONObject jsonObject1 = JSONObject.parseObject(data.getExtInfo());
+        extInfo = jsonObject1.toJavaObject(com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto.class);
 
-    /**
-     * 订单退款配置查询
-     *
-     * @return true=可同意退款
-     */
-    public boolean getRefundConfig(OrderInfoReqs order) {
-        return getRefundConfig(order.getPartnerId(), order.getOrderType(), order.getBizType(),
-                order.getMarketingType(), order.getOrderState(), order.getExtInfo());
+        // 查询小程序配置的退款设置
+        String redisKey = MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, data.getCompanyId(), extInfo.getAppid());
+        String hashKey;
+        if(MarketTypeEnum.CASHIER.getIndex().byteValue() == data.getMarketingType()){
+            //收银单，使用收银单的退款配置
+            hashKey = OrderRedisKeyConstant.HashKeyForOrderRefundConfig.CASHIER;
+        } else {
+            hashKey = OrderType.TAKE_OUT.getCode().equals(data.getOrderType())
+                    ? OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT
+                    : OrderRedisKeyConstant.HashKeyForOrderRefundConfig.EAT_IN;
+        }
+        String configStr = redisCache.hashGet(redisKey, hashKey);
+        if (StringUtils.isEmpty(configStr)) {
+            return true;
+        }
+        OrderRefundConfigEntity config = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
+        String orderRefund = null;
+        if(MarketTypeEnum.CASHIER.getIndex().byteValue() == data.getMarketingType()){
+            //收银单，使用收银单的退款配置 收银单只有完成的订单，直接判断是否可以退款就行
+            orderRefund = config.getCashierOrderRefund();
+        } else if (OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
+            //外卖单，使用外卖单的退款配置
+            switch (data.getStatus()) {
+                // 未接单
+                case 1: orderRefund = config.getDeliveryTakeOrderRefund(); break;
+                //已接单
+                case 3: orderRefund = config.getDeliveryReceiptOrderRefund(); break;
+                //制作完成
+                case 31: orderRefund = config.getDeliveryCompleteMakeOrderRefund(); break;
+                // 订单完成
+                case 5: orderRefund = config.getDeliveryOrderRefund(); break;
+                default: break;
+            }
+        } else {
+            //其他，使用堂食的退款配置（必须先判断收银单，因为收银单的类型也是堂食，只是orderClient不一样
+            switch (data.getStatus()) {
+                // 未接单
+                case 1: orderRefund = config.getTakeOrderRefund(); break;
+                //已接单
+                case 3: orderRefund = config.getReceiptOrderRefund(); break;
+                //制作完成
+                case 31: orderRefund = config.getCompleteMakeOrderRefund(); break;
+                // 订单完成
+                case 5: orderRefund = config.getOrderRefund(); break;
+                default: break;
+            }
+        }
+        return ALLOW_REFUND.equals(orderRefund);
     }
 
     /**
@@ -607,22 +551,22 @@ public class OrderVerifyHandle {
      *
      * @return true=可同意退款
      */
-    private boolean getRefundConfig(String partnerId, Integer orderType, Integer bizType, Integer marketType, Integer orderState, String extStr) {
-        // [华莱士20210410] 微商城订单判断
-        if(Objects.equals(BizTypeEnum.MALL.getBizType(), bizType)){
+    public boolean getRefundConfig(OrderInfoReqs order) {
+        // 微商城订单判断
+        if(Objects.equals(BizTypeEnum.MALL.getBizType(),order.getBizType())){
             // 除 未支付 拒单 和 取消外，其他可退款
-            return Stream.of(OrderStatusV1.WAIT_PAY,OrderStatusV1.CANCEL).noneMatch(s -> Objects.equals(orderState,s.getV2Code()));
+            return Stream.of(NewOrderStatus.PENDING_PAYMENT, NewOrderStatus.CLOSED)
+                    .noneMatch(s -> Objects.equals(order.getOrderState(), s.getIndex()));
         }
-        OrderExtInfoDto extInfo = JSON.parseObject(extStr, OrderExtInfoDto.class);
-
+        OrderExtInfoDto extInfo = JSON.parseObject(order.getExtInfo(), OrderExtInfoDto.class);
         // 查询小程序配置的退款设置
-        String redisKey = MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, partnerId, extInfo.getAppid());
+        String redisKey = MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, order.getPartnerId(), extInfo.getAppid());
         String hashKey;
-        if(MarketTypeEnum.CASHIER.getIndex().equals(marketType)){
+        if(MarketTypeEnum.CASHIER.getIndex().byteValue() == order.getMarketingType()){
             //收银单，使用收银单的退款配置
             hashKey = OrderRedisKeyConstant.HashKeyForOrderRefundConfig.CASHIER;
         } else {
-            hashKey = OrderType.TAKE_OUT.getCode().equals(orderType)
+            hashKey = NewOrderType.isDelivery(order.getOrderType())
                     ? OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT
                     : OrderRedisKeyConstant.HashKeyForOrderRefundConfig.EAT_IN;
         }
@@ -632,16 +576,14 @@ public class OrderVerifyHandle {
         }
         OrderRefundConfigEntity config = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
         String orderRefund = null;
-        if(MarketTypeEnum.CASHIER.getIndex().byteValue() == marketType){
+        if(MarketTypeEnum.CASHIER.getIndex().byteValue() == order.getMarketingType()){
             //收银单，使用收银单的退款配置 收银单只有完成的订单，直接判断是否可以退款就行
             orderRefund = config.getCashierOrderRefund();
-        } else if (OrderType.TAKE_OUT.getCode().equals(orderType)) {
+        } else if (NewOrderType.isDelivery(order.getOrderType())) {
             //外卖单，使用外卖单的退款配置
-            switch (orderState) {
+            switch (order.getOrderState()) {
                 // 未接单
-                case 1:
-                case 2:
-                    orderRefund = config.getDeliveryTakeOrderRefund(); break;
+                case 2: orderRefund = config.getDeliveryTakeOrderRefund(); break;
                 //已接单
                 case 3: orderRefund = config.getDeliveryReceiptOrderRefund(); break;
                 //制作完成
@@ -652,11 +594,9 @@ public class OrderVerifyHandle {
             }
         } else {
             //其他，使用堂食的退款配置（必须先判断收银单，因为收银单的类型也是堂食，只是orderClient不一样
-            switch (orderState) {
+            switch (order.getOrderState()) {
                 // 未接单
-                case 1:
-                case 2:
-                    orderRefund = config.getTakeOrderRefund(); break;
+                case 2: orderRefund = config.getTakeOrderRefund(); break;
                 //已接单
                 case 3: orderRefund = config.getReceiptOrderRefund(); break;
                 //制作完成
@@ -675,44 +615,19 @@ public class OrderVerifyHandle {
      */
     public BigDecimal getRefundAmount(OrderBeanV1 data,boolean isRefundDeliveryFee) {
         //是否配置已完成订单可退款
-        BigDecimal refundAmount = new BigDecimal(data.getAmount());
-//        if (isRefundDeliveryFee || isPayBySVC(data)){
-//            return refundAmount;
-//        }
-//        List<AccountBeanV1> accountList = data.getAccountList();
-//        if (CollectionUtils.isNotEmpty(accountList)) {
-//            for (AccountBeanV1 orderCostResp : accountList) {
-//                if (orderCostResp.getType() == OldOrderAccountType.DELIVERY_AMOUNT.getCode()) {
-//                    refundAmount = new BigDecimal(data.getAmount().intValue() - orderCostResp.getPrice());
-//                }
-//            }
-//        }
-        return refundAmount;
-    }
-    /**
-     * 订单是否使用储值卡支付（储值卡支付的订单，不支持部分退款）
-     *
-     * @param order
-     * @return true-是，false-不是
-     */
-    private boolean isPayBySVC(OrderBeanV1 order) {
-        return PAY_CODE_10102.equalsIgnoreCase(order.getPayChannel());
+        return new BigDecimal(data.getAmount());
     }
 
+
     /**
      * 需要三方配送的saas外卖
      * @param orderBean
      * @return
      */
     private boolean checkSaasWm(OrderBeanV1 orderBean) {
-        //
-        if (1 == orderBean.getOrderType()
+        return 1 == orderBean.getOrderType()
                 && OrderSourceV1.SAAS.getCode().equals(orderBean.getSource())
-                && THIRD.equalsIgnoreCase(orderBean.getAddInfo().getDeliveryType())) {
-            return true;
-        } else {
-            return false;
-        }
+                && THIRD.equalsIgnoreCase(orderBean.getAddInfo().getDeliveryType());
     }
     private boolean verifyThirdFlow(OrderBeanV1 orderBean,OrderManagerRequest request) {
         // 运单异常 运单取消  正常的运单是不允许手工操作流转的
@@ -742,20 +657,6 @@ public class OrderVerifyHandle {
         if (orderBean.getHasRefund() == null || !orderBean.getHasRefund()) {
             return ResponseUtil.error(ResponseResult.ORDER_REFUND_NOT_APPLY);
         }
-//        //订单是否支持退款
-//        boolean isCanRefund = false;
-//        //订单
-//        boolean isRefundDeliveryFee=false;
-//        //saas渠道订单，已完成的订单不能操作, 商户配置已完成订单可退款可退款
-//        if (ObjectUtils.equals(orderBean.getBizType(), BizTypeEnum.MALL.getBizType())) {
-//            isCanRefund = getRefundConfig(orderBean);
-//            if (!isCanRefund) {
-//                return ResponseUtil.error(ResponseResult.ORDER_HAD_AFFIRM_CAN_NOT_REFUND);
-//            }
-//        }
-//        if (isCanRefund) {
-//            orderBean.setAmount(getRefundAmount(orderBean,isRefundDeliveryFee).longValue());
-//        }
         return ResponseUtil.success();
     }