无单收银支持退款配置

assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/constant/OrderRedisKeyConstant.java

+package com.freemud.sdk.api.assortment.order.constant;
+
+/**
+ * @author Clover.z
+ * @Date 2021/8/11
+ * @Desc
+ */
+public class OrderRedisKeyConstant {
+
+
+    /**
+     * 订单是否支持退款配置 缓存key
+     *  0：商户号
+     *  1：小程序appId
+     *
+     *  value: hash结构
+     *      hkey : HashKeyForOrderRefundConfig中定义
+     *      具体配置为json字符串
+     *  @see HashKeyForOrderRefundConfig
+     */
+    public static final String ORDER_REFUND_CONFIG = "kgd:order_refund_config_{0}_{1}";
+    /**
+     * 订单是否支持退款配置 缓存key的value中 hashKey的枚举
+     * 对于的值为json字符串
+     * @see com.freemud.sdk.api.assortment.order.entities.OrderRefundConfigEntity
+     */
+    public static class HashKeyForOrderRefundConfig {
+        /**
+         *  订单类型为堂食单 redis配置的hkey 对于的值为json字符串
+         */
+        public static final String EAT_IN = "eatInType";
+        /**
+         *  订单类型为外卖单 redis配置的hkey 对于的值为json字符串
+         */
+        public static final String TAKE_OUT = "takeOutType";
+        /**
+         *  订单类型为收银单 redis配置的hkey 对于的值为json字符串
+         */
+        public static final String CASHIER = "cashierType";
+    }
+
+
+    /**
+     * 订单配置 缓存key
+     *  0：商户号
+     *  1：小程序appId
+     *
+     *  value: hash结构
+     *      hkey : HashKeyForOrderComplainConfig
+     *      具体配置为json字符串
+     *  @see HashKeyForOrderRefundConfig
+     */
+    public static final String ORDER_COMPLAIN_KEY = "kgd:order_config_{0}_{1}";
+    /**
+     * 订单售后信息相关配置hashKey
+     */
+    public static class HashKeyForOrderComplainConfig {
+        /**
+         *  订单售后是否可申诉开关
+         *  hashKey 对于的值为 open/close
+         */
+        public static final String ORDER_COMPLAIN_TYPE = "orderComplaintType";
+    }
+
+
+
+
+
+
+
+}

assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/entities/OrderRefundConfigEntity.java

+package com.freemud.sdk.api.assortment.order.entities;
+
+import lombok.Data;
+
+/**
+ * @author Clover.z
+ * @Date 2021/10/19
+ * @Desc 订单退款配置
+ */
+@Data
+public class OrderRefundConfigEntity {
+
+    /**
+     * 未接单状态是否允许退款:
+     *  0-不允许
+     *  1-允许
+     */
+    private String takeOrderRefund;
+
+    /**
+     * 已接单状态是否允许退款:
+     *  0-不允许
+     *  1-允许
+     */
+    private String receiptOrderRefund;
+
+    /**
+     * 制作完成是否支持退款
+     * 0-不允许
+     * 1-允许
+     */
+    private String completeMakeOrderRefund;
+
+    /**
+     * 已完成订单是否允许退款
+     * 0-不允许
+     * 1-允许
+     */
+    private String orderRefund;
+
+    /**
+     * 外卖单未接单是否支持退款
+     *  0-不允许
+     *  1-允许
+     */
+    private String deliveryTakeOrderRefund;
+
+    /**
+     * 外卖单已接单是否支持退款
+     *  0-不允许
+     *  1-允许
+     */
+    private String deliveryReceiptOrderRefund;
+
+    /**
+     * 外卖单制作完成是否支持退款
+     *  0-不允许
+     *  1-允许
+     */
+    private String deliveryCompleteMakeOrderRefund;
+
+    /**
+     * 外卖单订单完成是否支持退款
+     *  0-不允许
+     *  1-允许
+     */
+    private String deliveryOrderRefund;
+
+    /**
+     * 退款允许日期
+     */
+    private String refundDateRange;
+
+    /**
+     * 商家同意退款时是否退配送费
+     *  0-不允许
+     *  1-允许
+     */
+    private String refundShippingFee;
+
+    /**
+     * 退款退优惠券
+     *  0-不允许
+     *  1-允许
+     */
+    private String refundReverseCoupon;
+
+    /**
+     * 收银订单是否允许退款
+     * 0-不允许
+     * 1-允许
+     */
+    private String cashierOrderRefund;
+}

order-application-service/src/main/java/cn/freemud/adapter/OrderAdapter.java

@@ -13,7 +13,10 @@
 package cn.freemud.adapter;
 
 import cn.freemud.base.util.DateUtil;
-import cn.freemud.constant.*;
+import cn.freemud.constant.CommonsConstant;
+import cn.freemud.constant.CustomerScoreConstant;
+import cn.freemud.constant.RedisKeyConstant;
+import cn.freemud.constant.ResponseCodeConstant;
 import cn.freemud.entities.dto.*;
 import cn.freemud.entities.dto.activity.ShareDiscountActivityDto;
 import cn.freemud.entities.dto.order.CreateOrderAccountDto;
@@ -61,14 +64,16 @@ import com.freemud.application.sdk.api.ordercenter.request.OrderConditionsReq;
 import com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto;
 import com.freemud.application.sdk.api.ordercenter.request.OrderExtendedReq;
 import com.freemud.application.sdk.api.ordercenter.response.BaseDownLoadResponse;
-import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderPayItemResp;
 import com.freemud.application.sdk.api.ordercenter.response.orderInfo.AfterSalesOrderResp;
 import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderInfoReqs;
+import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderPayItemResp;
 import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderSettlementResp;
 import com.freemud.application.sdk.api.promotioncenter.dto.promotion.GoodsStockDTO;
 import com.freemud.application.sdk.api.promotioncenter.request.promotion.ActivityUpdateStockRequest;
 import com.freemud.application.sdk.api.storecenter.response.StoreResponse;
 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.enums.*;
 import com.freemud.sdk.api.assortment.order.request.order.*;
 import com.freemud.sdk.api.assortment.order.request.payment.CombPayRequest;
@@ -77,7 +82,6 @@ import com.freemud.sdk.api.assortment.order.request.payment.ProductVO;
 import com.freemud.sdk.api.assortment.order.response.order.CreateOrderFlowResponse;
 import com.freemud.sdk.api.assortment.order.response.order.QueryOrderByIdResponse;
 import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
-//import com.freemud.sdk.api.assortment.order.response.payment.OrderPayResponse;
 import com.freemud.sdk.api.assortment.payment.request.UnifiedOrderRequest;
 import com.freemud.sdk.api.assortment.payment.response.UnifiedOrderResponse;
 import com.google.common.collect.Lists;
@@ -1181,7 +1185,7 @@ public class OrderAdapter {
         if (null != orderBean) {
             partnerId = orderBean.getCompanyId();
         }
-        String configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_COMPLAIN_KEY, partnerId, wxAppId), KgdRedisKeyConstant.ORDER_COMPLAIN_TYPE);
+        String configStr = redisCache.hashGet(MessageFormat.format(OrderRedisKeyConstant.ORDER_COMPLAIN_KEY, partnerId, wxAppId), OrderRedisKeyConstant.HashKeyForOrderComplainConfig.ORDER_COMPLAIN_TYPE);
         Boolean buttonComplain = false;
         if (CommonsConstant.ORDER_COMPLAIN_OPEN.equals(configStr)) {
             buttonComplain = true;
@@ -2144,82 +2148,72 @@ public class OrderAdapter {
         }
 
         boolean canRefund = false;
-        String hkey = OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType()) ? KgdRedisKeyConstant.REFUND_CFG_TAKE_OUT : KgdRedisKeyConstant.REFUND_CFG_EAT_IN;
-        String configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId), hkey);
+        // 查询小程序配置的退款设置
+        String redisKey = MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId);
+        String hashKey;
+        if (OrderClientType.CASHIER.getIndex().toString().equals(orderBean.getOrderClient())) {
+            //收银单，使用收银单的退款配置
+            hashKey = OrderRedisKeyConstant.HashKeyForOrderRefundConfig.CASHIER;
+        } else {
+            hashKey = OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())
+                    ? OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT
+                    : OrderRedisKeyConstant.HashKeyForOrderRefundConfig.EAT_IN;
+        }
+        String configStr = redisCache.hashGet(redisKey, hashKey);
         if (StringUtils.isEmpty(configStr)) {
             return true;
         }
-        JSONObject config = JSON.parseObject(configStr);
-        String orderRefund;
-
-        //订单状态
-        switch (status) {
-            // 未接单
-            case TAKE_ORDER:
-                //区分外卖单和到店订单，判断是否可以退款
-                if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
-                    orderRefund = config.getString(OrderRefundEnum.DELIVERY_TAKE_ORDER_REFUND.getKeyValue());
-                } else {
-                    orderRefund = config.getString(OrderRefundEnum.TAKEORDER_REFUND.getKeyValue());
-                }
-                if (orderRefund == null || ALLOW_REFUND.equals(orderRefund)) {
-                    canRefund = true;
-                }
-                break;
-            //已接单
-            case RECEIPT:
-                if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
-                    orderRefund = config.getString(OrderRefundEnum.DELIVERY_RECEIPT_ORDER_REFUND.getKeyValue());
-                } else {
-                    orderRefund = config.getString(OrderRefundEnum.RECEIPTORDER_REFUND.getKeyValue());
-                }
-                if (orderRefund == null || ALLOW_REFUND.equals(orderRefund)) {
-                    canRefund = true;
-                }
-                break;
-            //制作完成
-            case COMPLETE_MAKE:
-                if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
-                    orderRefund = config.getString(OrderRefundEnum.DELIVERY_COMPLETE_MAKE_ORDER_REFUND.getKeyValue());
-                } else {
-                    orderRefund = config.getString(OrderRefundEnum.COMPLETEMAKEORDER_REFUND.getKeyValue());
-                }
-                if (orderRefund != null && ALLOW_REFUND.equals(orderRefund)) {
-                    canRefund = true;
-                }
-                break;
-            // 订单完成
-            case COMPLETE:
-                long currentTime = System.currentTimeMillis();
-                long gmtModified = orderBean.getGmtModified();
-
-                // 因允许退款日期在外卖类型的value中，如果订单类型为堂食，则会取不到这个值
-                if (!OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
-                    configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId), KgdRedisKeyConstant.REFUND_CFG_TAKE_OUT);
-                    if (StringUtils.isNotEmpty(configStr)) {
-                        // 将允许退款日期的配置放到config中
-                        config.put(OrderRefundEnum.REFUND_DATA_RANGE.getKeyValue(), JSON.parseObject(configStr).getString(OrderRefundEnum.REFUND_DATA_RANGE.getKeyValue()));
-                    }
-                }
-                long value = 0L;
-                String refundDateConfig = config.getString(OrderRefundEnum.REFUND_DATA_RANGE.getKeyValue());
-                if (null != refundDateConfig) {
-                    value = Long.parseLong(StringUtils.isEmpty(refundDateConfig) ? "0" : refundDateConfig);
-                }
-                long allowRefundTime = gmtModified + value * 24 * 60 * 60 * 1000;
-
-                if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
-                    orderRefund = config.getString(OrderRefundEnum.DELIVERY_ORDER_REFUND.getKeyValue());
-                } else {
-                    orderRefund = config.getString(OrderRefundEnum.ORDER_REFUND.getKeyValue());
-                }
-                if (orderRefund != null && ALLOW_REFUND.equals(orderRefund) && (allowRefundTime - currentTime) >= 0) {
-                    canRefund = true;
+        OrderRefundConfigEntity config = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
+        String orderRefund = null;
+        if (OrderClientType.CASHIER.getIndex().toString().equals(orderBean.getOrderClient())) {
+            //收银单，使用收银单的退款配置 收银单只有完成的订单，直接判断是否可以退款就行
+            orderRefund = config.getCashierOrderRefund();
+        } else if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
+            //外卖单，使用外卖单的退款配置
+            switch (status) {
+                // 未接单
+                case TAKE_ORDER: orderRefund = config.getDeliveryTakeOrderRefund(); break;
+                //已接单
+                case RECEIPT: orderRefund = config.getDeliveryReceiptOrderRefund(); break;
+                //制作完成
+                case COMPLETE_MAKE: orderRefund = config.getDeliveryCompleteMakeOrderRefund(); break;
+                // 订单完成
+                case COMPLETE: orderRefund = config.getDeliveryOrderRefund(); break;
+                default: break;
+            }
+        } else {
+            //其他，使用堂食的退款配置（必须先判断收银单，因为收银单的类型也是堂食，只是orderClient不一样
+            switch (status) {
+                // 未接单
+                case TAKE_ORDER: orderRefund = config.getTakeOrderRefund(); break;
+                //已接单
+                case RECEIPT: orderRefund = config.getReceiptOrderRefund(); break;
+                //制作完成
+                case COMPLETE_MAKE: orderRefund = config.getCompleteMakeOrderRefund(); break;
+                // 订单完成
+                case COMPLETE: orderRefund = config.getOrderRefund(); break;
+                default: break;
+            }
+        }
+        canRefund = ALLOW_REFUND.equals(orderRefund);
+        // 如果是订单完成状态的 支持退款， 这里还需要校验一下是否在退款时间范围内
+        if (OrderStatus.COMPLETE.getCode().equals(status.getCode()) && canRefund) {
+            long currentTime = System.currentTimeMillis();
+            long gmtModified = orderBean.getGmtModified();
+            // 因允许退款日期在外卖类型的value中，如果订单类型为堂食，则会取不到这个值
+            if (!OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
+                configStr = redisCache.hashGet(redisKey, OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT);
+                if (StringUtils.isNotEmpty(configStr)) {
+                    OrderRefundConfigEntity ce = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
+                    config.setRefundDateRange(ce.getRefundDateRange());
                 }
-                break;
-            default:
-                break;
-
+            }
+            //退款日期允许范围
+            long value = 0L;
+            if (StringUtils.isNotEmpty(config.getRefundDateRange())) {
+                value = Long.parseLong(config.getRefundDateRange());
+            }
+            canRefund = ((gmtModified + value * 24 * 60 * 60 * 1000) - currentTime) >= 0;
         }
         return canRefund;
     }

order-application-service/src/main/java/cn/freemud/constant/KgdRedisKeyConstant.java

-package cn.freemud.constant;
-
-/**
- * @author Clover.z
- * @Date 2021/8/11
- * @Desc
- */
-public class KgdRedisKeyConstant {
-
-
-    /**
-     * 订单是否支持退款配置 缓存key
-     *  0：商户号
-     *  1：小程序appId
-     *
-     *  value: hash结构
-     *      hkey : eatInType 堂食 和takeOutType 外卖
-     *      具体配置为json字符串
-     */
-    public static final String ORDER_REFUND_CONFIG = "kgd:order_refund_config_{0}_{1}";
-    /**
-     *  订单类型为堂食 redis配置的hkey
-     */
-    public static final String REFUND_CFG_EAT_IN = "eatInType";
-    /**
-     *  订单类型为外卖 redis配置的hkey
-     */
-    public static final String REFUND_CFG_TAKE_OUT = "takeOutType";
-
-    public static final String ORDER_COMPLAIN_KEY = "kgd:order_config_{0}_{1}";
-
-    public static final String ORDER_COMPLAIN_TYPE = "orderComplaintType";
-
-
-
-
-
-
-}

order-application-service/src/main/java/cn/freemud/entities/CashierOrderRefundConfigEntity.java

-package cn.freemud.entities;
-
-import lombok.Data;
-
-/**
- * @author Clover.z
- * @Date 2021/10/19
- * @Desc 无单收银类 订单退款配置
- */
-@Data
-public class CashierOrderRefundConfigEntity {
-
-    /**
-     * 订单完成状态是否允许退款
-     *  0-不允许
-     *  1-允许
-     */
-    private Integer allowRefund;
-
-    /**
-     * 订单完成后，{refundDateRange} 天内可申请退款
-     */
-    private Integer refundDateRange;
-
-}

order-application-service/src/main/java/cn/freemud/enums/OrderRefundEnum.java

-package cn.freemud.enums;
-
-/**
- * All rights Reserved, Designed By www.freemud.cn
- *
- * @version V1.0
- * @Title: OrderRefundEnum
- * @Package cn.freemud.constant
- * @Description:
- * @author: bowen.hu
- * @date: 2019-09-17 10:46
- * @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
- * 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目的
- */
-public enum OrderRefundEnum {
-
-    ORDER_REFUND("orderRefund", "已完成订单是否允许退款"),
-    TAKEORDER_REFUND("takeOrderRefund", "未接单是否支持退款"),
-    RECEIPTORDER_REFUND("receiptOrderRefund", "已接单是否支持退款"),
-    COMPLETEMAKEORDER_REFUND("completeMakeOrderRefund", "制作完成是否支持退款"),
-
-    DELIVERY_TAKE_ORDER_REFUND("deliveryTakeOrderRefund","外卖单未接单是否支持退款"),
-    DELIVERY_RECEIPT_ORDER_REFUND("deliveryReceiptOrderRefund","外卖单已接单是否支持退款"),
-    DELIVERY_COMPLETE_MAKE_ORDER_REFUND("deliveryCompleteMakeOrderRefund","外卖单制作完成是否支持退款"),
-    DELIVERY_ORDER_REFUND("deliveryOrderRefund","外卖单订单完成是否支持退款"),
-    REFUND_DATA_RANGE("refundDateRange", "退款允许日期"),
-    REFUND_DELIVERY_FEE_ENABLE("refundShippingFee","商家同意退款时是否退配送费"),
-    REFUND_REVERSE_COUPON("refundReverseCoupon", "退款退优惠券");
-    ;
-
-    private String keyValue;
-
-    private String message;
-
-    OrderRefundEnum(String keyValue, String message) {
-        this.keyValue = keyValue;
-        this.message = message;
-    }
-
-    public String getKeyValue() {
-        return keyValue;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-
-
-}

order-application-service/src/main/java/cn/freemud/service/impl/OrderServiceImpl.java

@@ -15,7 +15,6 @@ package cn.freemud.service.impl;
 import cn.freemud.adapter.*;
 import cn.freemud.base.entity.BaseResponse;
 import cn.freemud.base.util.DateUtil;
-import cn.freemud.constant.KgdRedisKeyConstant;
 import cn.freemud.constant.OrderRefundConstant;
 import cn.freemud.constant.RedisKeyConstant;
 import cn.freemud.constant.ResponseCodeConstant;
@@ -110,6 +109,8 @@ import com.freemud.sdk.api.assortment.message.request.MessagePushOrderTemplateRe
 import com.freemud.sdk.api.assortment.message.request.MessageTemplateRequest;
 import com.freemud.sdk.api.assortment.message.service.IMessageTemplatePushService;
 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.enums.AutoOrderConfigTime;
 import com.freemud.sdk.api.assortment.order.enums.NewOrderType;
 import com.freemud.sdk.api.assortment.order.enums.OldOrderStatus;
@@ -1979,10 +1980,10 @@ public class OrderServiceImpl implements Orderservice {
                 }
             }else {
                 // 查询小程序是否配置了退运费
-                String configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId), KgdRedisKeyConstant.REFUND_CFG_TAKE_OUT);
+                String configStr = redisCache.hashGet(MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId), OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT);
                 if (StringUtils.isNotEmpty(configStr)) {
-                    JSONObject config = JSON.parseObject(configStr);
-                    String refundDeliveryFeeConfig = config.getString(OrderRefundEnum.REFUND_DELIVERY_FEE_ENABLE.getKeyValue());
+                    OrderRefundConfigEntity config = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
+                    String refundDeliveryFeeConfig = config.getRefundShippingFee();
                     // 0、null表示 关闭 ; 1 表示开启
                     if (null != refundDeliveryFeeConfig
                             && Arrays.asList(OrderStatus.DISTRIBUTION.getCode(), OrderStatus.COMPLETE.getCode()).contains(orderBean.getStatus())

order-management/src/main/java/cn/freemud/management/constant/KgdRedisKeyConstant.java

-package cn.freemud.management.constant;
-
-/**
- * @author Clover.z
- * @Date 2021/8/11
- * @Desc
- */
-public class KgdRedisKeyConstant {
-
-
-    /**
-     * 订单是否支持退款配置 缓存key
-     *  0：商户号
-     *  1：小程序appId
-     *
-     *  value: hash结构
-     *      hkey : eatInType 堂食 和takeOutType 外卖
-     *      具体配置为json字符串
-     */
-    public static final String ORDER_REFUND_CONFIG = "kgd:order_refund_config_{0}_{1}";
-    /**
-     *  订单类型为堂食 redis配置的hkey
-     */
-    public static final String REFUND_CFG_EAT_IN = "eatInType";
-    /**
-     *  订单类型为外卖 redis配置的hkey
-     */
-    public static final String REFUND_CFG_TAKE_OUT = "takeOutType";
-
-
-}

order-management/src/main/java/cn/freemud/management/enums/OrderRefundEnum.java

-package cn.freemud.management.enums;
-
-/**
- * All rights Reserved, Designed By www.freemud.cn
- *
- * @version V1.0
- * @Title: OrderRefundEnum
- * @Package cn.freemud.constant
- * @Description:
- * @author: bowen.hu
- * @date: 2019-09-17 10:46
- * @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
- * 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目的
- */
-public enum OrderRefundEnum {
-
-    ORDER_REFUND("orderRefund", "已完成订单是否允许退款"),
-    TAKEORDER_REFUND("takeOrderRefund", "未接单是否支持退款"),
-    RECEIPTORDER_REFUND("receiptOrderRefund", "已接单是否支持退款"),
-    COMPLETEMAKEORDER_REFUND("completeMakeOrderRefund", "制作完成是否支持退款"),
-
-    DELIVERY_TAKE_ORDER_REFUND("deliveryTakeOrderRefund","外卖单未接单是否支持退款"),
-    DELIVERY_RECEIPT_ORDER_REFUND("deliveryReceiptOrderRefund","外卖单已接单是否支持退款"),
-    DELIVERY_COMPLETE_MAKE_ORDER_REFUND("deliveryCompleteMakeOrderRefund","外卖单制作完成是否支持退款"),
-    DELIVERY_ORDER_REFUND("deliveryOrderRefund","外卖单订单完成是否支持退款"),
-    REFUND_DATA_RANGE("refundDateRange", "退款允许日期"),
-    REFUND_DELIVERY_FEE_ENABLE("refundShippingFee","商家同意退款时是否退配送费"),
-    REFUND_REVERSE_COUPON("refundReverseCoupon", "退款退优惠券");
-
-    private String keyValue;
-
-    private String message;
-
-    OrderRefundEnum(String keyValue, String message) {
-        this.keyValue = keyValue;
-        this.message = message;
-    }
-
-    public String getKeyValue() {
-        return keyValue;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-
-
-}

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

 package cn.freemud.management.service.handle;
 
 import cn.freemud.base.entity.BaseResponse;
-import cn.freemud.management.constant.KgdRedisKeyConstant;
 import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
 import cn.freemud.management.entities.dto.response.order.OrderManagerResponse;
 import cn.freemud.management.enums.*;
@@ -14,8 +13,11 @@ import com.freemud.application.sdk.api.ordercenter.entities.v1.AccountBeanV1;
 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.OperateClient;
+import com.freemud.application.sdk.api.ordercenter.enums.OrderClientType;
 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.enums.OldOrderAccountType;
 import com.freemud.sdk.api.assortment.order.enums.OldOrderType;
 import com.freemud.sdk.api.assortment.order.enums.OrderSourceType;
@@ -565,78 +567,63 @@ public class OrderVerifyHandle {
      */
     private boolean getRefundConfig(OrderBeanV1 data) {
         boolean isFinishRefund = false;
-
         // [华莱士20210410] 微商城订单判断
         if(Objects.equals(com.freemud.sdk.api.assortment.order.enums.OrderSourceType.SAASMALL.getCode(),data.getSource()) ){
             // 除 未支付 拒单 和 取消外，其他可退款
             return Stream.of(OrderStatus.WAIT_PAY,OrderStatus.REFUSE,OrderStatus.CANCEL).noneMatch(s -> Objects.equals(data.getStatus(),s.getCode()));
         }
-
         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);
 
         // 查询小程序配置的退款设置
-        String hkey = OrderType.TAKE_OUT.getCode().equals(data.getOrderType()) ? KgdRedisKeyConstant.REFUND_CFG_TAKE_OUT : KgdRedisKeyConstant.REFUND_CFG_EAT_IN;
-        String configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_REFUND_CONFIG, data.getCompanyId(), extInfo.getAppid()), hkey);
+        String redisKey = MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, data.getCompanyId(), extInfo.getAppid());
+        String hashKey;
+        if (OrderClientType.CASHIER.getIndex().toString().equals(data.getOrderClient())) {
+            //收银单，使用收银单的退款配置
+            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;
         }
-        JSONObject config = JSON.parseObject(configStr);
-        String orderRefund;
-
-        //订单状态
-        switch (data.getStatus()) {
-            // 未接单
-            case 1:
-                //区分外卖单和到店订单，判断是否可以退款
-                if(OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
-                    orderRefund = config.getString(OrderRefundEnum.DELIVERY_TAKE_ORDER_REFUND.getKeyValue());
-                }else {
-                    orderRefund = config.getString(OrderRefundEnum.TAKEORDER_REFUND.getKeyValue());
-                }
-                if (orderRefund == null || (orderRefund != null && ALLOW_REFUND.equals(orderRefund))) {
-                    isFinishRefund = true;
-                }
-                break;
-            //已接单
-            case 3:
-                if(OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
-                    orderRefund = config.getString(OrderRefundEnum.DELIVERY_RECEIPT_ORDER_REFUND.getKeyValue());
-                }else {
-                    orderRefund = config.getString(OrderRefundEnum.RECEIPTORDER_REFUND.getKeyValue());
-                }
-                if (orderRefund == null || (orderRefund != null && ALLOW_REFUND.equals(orderRefund))) {
-                    isFinishRefund = true;
-                }
-                break;
-            //制作完成
-            case 31:
-                if(OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
-                    orderRefund = config.getString(OrderRefundEnum.DELIVERY_COMPLETE_MAKE_ORDER_REFUND.getKeyValue());
-                }else {
-                    orderRefund = config.getString(OrderRefundEnum.COMPLETEMAKEORDER_REFUND.getKeyValue());
-                }
-                if (orderRefund != null && ALLOW_REFUND.equals(orderRefund)) {
-                    isFinishRefund = true;
-                }
-                break;
-            // 订单完成
-            case 5:
-                if(OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
-                    orderRefund = config.getString(OrderRefundEnum.DELIVERY_ORDER_REFUND.getKeyValue());
-                }else {
-                    orderRefund = config.getString(OrderRefundEnum.ORDER_REFUND.getKeyValue());
-                }
-                if (orderRefund != null && ALLOW_REFUND.equals(orderRefund)) {
-                    isFinishRefund = true;
-                }
-                break;
-            default:
-                break;
-
+        OrderRefundConfigEntity config = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
+        String orderRefund = null;
+        if (OrderClientType.CASHIER.getIndex().toString().equals(data.getOrderClient())) {
+            //收银单，使用收银单的退款配置 收银单只有完成的订单，直接判断是否可以退款就行
+            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 isFinishRefund;
+        return ALLOW_REFUND.equals(orderRefund);
     }
 
     /**