其他支付（汇来米，收钱吧，现金，其他）调混合支付退款接口

order-application-service/src/main/java/cn/freemud/controller/OrderController.java

@@ -144,11 +144,11 @@ public class OrderController {
     /**
      * 订单支付成功后通知 老支付回掉，已不用废弃
      */
-    @ApiAnnotation(logMessage = "paySuccessCallback")
-    @PostMapping("/paySuccessCallback")
-    public String paySuccessCallback(@LogParams @RequestBody PaysuccessNoticeMessage message) {
-        return orderAdapterService.paySuccessCallback(message);
-    }
+//    @ApiAnnotation(logMessage = "paySuccessCallback")
+//    @PostMapping("/paySuccessCallback")
+//    public String paySuccessCallback(@LogParams @RequestBody PaysuccessNoticeMessage message) {
+//        return orderAdapterService.paySuccessCallback(message);
+//    }
 
     /**
      * 订单支付成功后通知
@@ -355,11 +355,11 @@ public class OrderController {
      * @param timeOutOrderVo
      * @return
      */
-    @ApiAnnotation(logMessage = "timeOutOrderRefund")
-    @PostMapping("/timeOutOrderRefund")
-    public BaseResponse timeOutOrderRefund(@Validated @LogParams @RequestBody TimeOutOrderVo timeOutOrderVo){
-        return orderservice.timeOutOrderRefund(timeOutOrderVo);
-    }
+//    @ApiAnnotation(logMessage = "timeOutOrderRefund")
+//    @PostMapping("/timeOutOrderRefund")
+//    public BaseResponse timeOutOrderRefund(@Validated @LogParams @RequestBody TimeOutOrderVo timeOutOrderVo){
+//        return orderservice.timeOutOrderRefund(timeOutOrderVo);
+//    }
     /**
      * 根据订单号查询配送操作日志及骑手位置
      * @param requestVo

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

@@ -111,7 +111,7 @@ public interface Orderservice extends OrderFactoryService{
      */
     BaseResponse queryCollageOrderById(Integer operation, String sessionId, String oid, String partnerId, String channel);
 
-    BaseResponse timeOutOrderRefund(TimeOutOrderVo timeOutOrderVo);
+//    BaseResponse timeOutOrderRefund(TimeOutOrderVo timeOutOrderVo);
 
     BaseResponse queryOrderRider(OrderRiderRequestVo requestVo);
 

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

@@ -348,7 +348,7 @@ public class OrderAdapterServiceImpl {
                 request.setPartnerId(orderBean.getCompanyId());
                 request.setReason("处理订单已关闭,支付未及时回调");
                 request.setOperator("order-application-service");
-                // 直接退款就行, 其他的资产已经被退回
+                // 直接退款就行, 其他的资产已经被退回 支付回调超时 订单已取消则做退款处理
                 paymentHandle.getCommonPayRefundResponse(request, orderBean);
                 return orderAdapter.sendPaySuccessNoticeMessage();
             }

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

@@ -1331,19 +1331,19 @@ public class OrderServiceImpl implements Orderservice {
         return ResponseUtil.success(responseVo);
     }
 
-    @Override
-    public BaseResponse timeOutOrderRefund(TimeOutOrderVo timeOutOrderVo) {
-        Map<String, OrderBeanV1> orderBeans = this.getOrderBeanByOrderId(timeOutOrderVo.getOid(), timeOutOrderVo.getPartnerId());
-        if (MapUtils.isEmpty(orderBeans)) {
-            ResponseUtil.error("404", "订单不存在");
-        }
-        OrderBeanV1 orderBean = orderBeans.get(OrderBeanType.SAASORDER.getCode());
-
-        if (NewOrderStatus.CLOSED.getIndex().equals(orderBean.getStatusV2())) {
-            this.timeOutRefund(orderBean);
-        }
-        return ResponseUtil.success();
-    }
+//    @Override
+//    public BaseResponse timeOutOrderRefund(TimeOutOrderVo timeOutOrderVo) {
+//        Map<String, OrderBeanV1> orderBeans = this.getOrderBeanByOrderId(timeOutOrderVo.getOid(), timeOutOrderVo.getPartnerId());
+//        if (MapUtils.isEmpty(orderBeans)) {
+//            ResponseUtil.error("404", "订单不存在");
+//        }
+//        OrderBeanV1 orderBean = orderBeans.get(OrderBeanType.SAASORDER.getCode());
+//
+//        if (NewOrderStatus.CLOSED.getIndex().equals(orderBean.getStatusV2())) {
+//            this.timeOutRefund(orderBean);
+//        }
+//        return ResponseUtil.success();
+//    }
 
     private String getRedpacketsPicture(String activityId) {
         if (StringUtils.isNotBlank(activityId)) {
@@ -2369,37 +2369,37 @@ public class OrderServiceImpl implements Orderservice {
      *
      * @param orderBean
      */
-    public void timeOutRefund(OrderBeanV1 orderBean) {
-        //调用支付退款
-        Integer abState = 4;
-        String noPay = "8200404";
-        //4 表示订单已经退款了
-        if (abState.equals(orderBean.getAbnormalState())) {
-            return;
-        }
-        OrderManagerRequest request = new OrderManagerRequest();
-        request.setReason("订单已关闭,支付未及时回调");
-        Integer state = com.freemud.sdk.api.assortment.order.enums.PayRefundStatus.SUCCESS.getCode();
-        PayRefundResponse commonPayRefundResponse = paymentHandle.getCommonPayRefundResponse(request, orderBean);
-        com.freemud.sdk.api.assortment.order.enums.PayRefundStatus payRefundStatus = commonPayRefundResponse.getPayRefundStatus();
-
-        SdkUpdateAbnormalState sdkUpdateAbnormalState = new SdkUpdateAbnormalState();
-        String desc = "支付未及时回调";
-        switch (payRefundStatus) {
-            case SUCCESS:
-                sdkUpdateAbnormalState.setAbnormalDesc(desc + ",退款成功");
-                break;
-            case FAIL:
-                sdkUpdateAbnormalState.setAbnormalDesc(desc + ",退款失败");
-                break;
-            default:
-                sdkUpdateAbnormalState.setAbnormalDesc(desc + ",等待支付回调中");
-        }
-        sdkUpdateAbnormalState.setPartnerId(orderBean.getCompanyId());
-        sdkUpdateAbnormalState.setAbnormalState(4);
-        sdkUpdateAbnormalState.setOrderCode(orderBean.getOid());
-        orderSdkService.updateAbnormalState(sdkUpdateAbnormalState);
-    }
+//    public void timeOutRefund(OrderBeanV1 orderBean) {
+//        //调用支付退款
+//        Integer abState = 4;
+//        String noPay = "8200404";
+//        //4 表示订单已经退款了
+//        if (abState.equals(orderBean.getAbnormalState())) {
+//            return;
+//        }
+//        OrderManagerRequest request = new OrderManagerRequest();
+//        request.setReason("订单已关闭,支付未及时回调");
+//        Integer state = com.freemud.sdk.api.assortment.order.enums.PayRefundStatus.SUCCESS.getCode();
+//        PayRefundResponse commonPayRefundResponse = paymentHandle.getCommonPayRefundResponse(request, orderBean);
+//        com.freemud.sdk.api.assortment.order.enums.PayRefundStatus payRefundStatus = commonPayRefundResponse.getPayRefundStatus();
+//
+//        SdkUpdateAbnormalState sdkUpdateAbnormalState = new SdkUpdateAbnormalState();
+//        String desc = "支付未及时回调";
+//        switch (payRefundStatus) {
+//            case SUCCESS:
+//                sdkUpdateAbnormalState.setAbnormalDesc(desc + ",退款成功");
+//                break;
+//            case FAIL:
+//                sdkUpdateAbnormalState.setAbnormalDesc(desc + ",退款失败");
+//                break;
+//            default:
+//                sdkUpdateAbnormalState.setAbnormalDesc(desc + ",等待支付回调中");
+//        }
+//        sdkUpdateAbnormalState.setPartnerId(orderBean.getCompanyId());
+//        sdkUpdateAbnormalState.setAbnormalState(4);
+//        sdkUpdateAbnormalState.setOrderCode(orderBean.getOid());
+//        orderSdkService.updateAbnormalState(sdkUpdateAbnormalState);
+//    }
 
     private Boolean isQueryEs(Integer queryOrderStatus) {
 
@@ -3085,6 +3085,7 @@ public class OrderServiceImpl implements Orderservice {
 
                 // TODO: 22-6-23 退款逻辑待合并
                 if (orderBean.getAmount() != 0) {
+                    //ka未迁移商户老接口 生产7天无日志，不做修改
                     if (null != orderBean.getOrderPayItem() && orderBean.getOrderPayItem().size() > 0) {
                         //调用支付退款
                         MultiOrderRefundRequest multiOrderRefundRequest = orderAdapter.getMultiOrderPayRefundRequest(orderBean, refundId);
@@ -3174,6 +3175,7 @@ public class OrderServiceImpl implements Orderservice {
         //支付退款
         PayRefundResponse refundResponse;
         try {
+            //ka未迁移商户老接口 生产7天无日志，不做修改
             if (null != orderBean.getOrderPayItem() && orderBean.getOrderPayItem().size() > 0) {
                 refundResponse = payServiceImpl.payRefundCommon(null, orderBean);
             } else {

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

@@ -1664,19 +1664,19 @@ public class PayServiceImpl {
     }
 
     /**
-     * 混合支付退款接口
+     * 混合支付退款接口 废弃
      */
+    @Deprecated
     public MultiOrderRefundResponse paymentApplicationRefund(MultiOrderRefundRequest multiOrderRefundRequest, String partnerId) {
         return mulitiPaymentClient.paymentApplicationRefund(multiOrderRefundRequest, partnerId);
     }
 
     /**
-     * 提取 退款公共代码
-     *
-     * @param request
-     * @param orderBean
-     * @return
+     * 废弃
+     * 商城拼团未成团退款
+     * ka未迁移商户退款 菜单卖券下单
      */
+    @Deprecated
     public PayRefundResponse payRefundCommon(OrderManagerRequest request, OrderBeanV1 orderBean) {
         PayRefundResponse refundResponse = paymentHandle.getCommonPayRefundResponse(request, orderBean);
         return refundResponse;

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

+package cn.freemud.management.service.handle;
+
+import cn.freemud.management.adapter.PaymentSdkAdapter;
+import cn.freemud.management.entities.dto.request.pay.AgentPayRefundReq;
+import cn.freemud.management.entities.dto.response.pay.AgentPayRefundResp;
+import cn.freemud.management.entities.dto.response.pay.PayRefundResponse;
+import cn.freemud.management.thirdparty.MulitiPaymentClient;
+import cn.freemud.management.util.RedisUtil;
+import cn.freemud.redis.RedisCache;
+import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderPayItemResp;
+import com.freemud.sdk.api.assortment.order.enums.PayRefundStatus;
+import com.freemud.sdk.api.assortment.order.request.order.MultiOrderRefundRequest;
+import com.freemud.sdk.api.assortment.order.response.order.MultiOrderRefundResponse;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+@Component
+public class MultiRefundService {
+
+    @Autowired
+    private PaymentSdkAdapter paymentSdkAdapter;
+    @Autowired
+    private MulitiPaymentClient mulitiPaymentClient;
+    @Autowired
+    private RedisCache redisCache;
+
+
+    /**
+     * 多种支付方式支付退款
+     */
+    public PayRefundResponse multiRefund(String partnerId, String storeCode, String orderCode, BigDecimal refundAmount,List<OrderPayItemResp> orderPayItem){
+        //是否多种支付方式支付退款
+        if(!getMultiRefund(orderPayItem)){
+            return null;
+        }
+        return multiRefund(partnerId, storeCode, orderCode, refundAmount);
+    }
+
+
+
+    /**
+     * 订单支付明细表新saas都会存数据，ka,pass商户需要兼容
+     * 是否多种支付方式支付退款 有储值卡支付，调混合支付退款接口 单宝其他支付方式支付退款（汇来米，收钱吧，现金，其他）
+     * @param orderPayItems
+     * @return
+     */
+    private Boolean getMultiRefund(List<OrderPayItemResp> orderPayItems){
+        boolean isMultiRefund = false;
+        if(CollectionUtils.isEmpty(orderPayItems)){
+            return isMultiRefund;
+        }
+        List<Integer> multiPayChannelType = Arrays.asList(3,10,50,51,52);
+        for(OrderPayItemResp orderPayItemResp : orderPayItems){
+            //有储值卡支付，调混合支付退款
+            if(multiPayChannelType.contains(orderPayItemResp.getPayChannelType())){
+                isMultiRefund = true;
+            }
+        }
+        return isMultiRefund;
+    }
+
+
+    /**
+     * 多种支付方式支付退款（包括储值卡退款，微信和储值卡，订单宝其他支付方式支付退款（汇来米，收钱吧，现金，其他））
+     */
+    private PayRefundResponse multiRefund(String partnerId, String storeCode, String orderCode, BigDecimal refundAmount) {
+        PayRefundStatus refundStatus = PayRefundStatus.SUCCESS;
+        MultiOrderRefundRequest req = paymentSdkAdapter.getMultiOrderPayRefundRequest(partnerId, storeCode, orderCode, refundAmount);
+        MultiOrderRefundResponse resp = mulitiPaymentClient.paymentApplicationRefund(req, partnerId);
+        String message = "";
+        if (Objects.isNull(resp) || resp.getCode() != 200) {
+            refundStatus = PayRefundStatus.FAIL;
+        } else {
+            MultiOrderRefundResponse.RefundPlatform data = resp.getData();
+            if (Objects.isNull(data) || CollectionUtils.isEmpty(data.refundPlatformResponseList)) {
+                refundStatus = PayRefundStatus.FAIL;
+            } else {
+                List<MultiOrderRefundResponse.RefundPlatformResponse> refundPlatformResponseList = data.refundPlatformResponseList;
+                redisCache.save(RedisUtil.getPaymentTransIdSequenceKey(refundPlatformResponseList.get(0).getTransId()), orderCode, 1L, TimeUnit.DAYS);
+
+                long refundError = refundPlatformResponseList.stream()
+                        .filter(s -> s.getResultCode().compareTo(MultiOrderRefundResponse.RefundPlatformResponse.REFUNDED_RESULTCODE) != 0
+                                && s.getResultCode().compareTo(MultiOrderRefundResponse.RefundPlatformResponse.REFUND_SUCCESS) != 0)
+                        .count();
+                if (refundError > 0L) {
+                    refundStatus = PayRefundStatus.FAIL;
+                }
+                // 退款中
+                long refunded = refundPlatformResponseList.stream()
+                        .filter(s -> s.getResultCode().compareTo(MultiOrderRefundResponse.RefundPlatformResponse.REFUNDED_RESULTCODE) == 0)
+                        .count();
+                if (refunded > 0L) {
+                    refundStatus = PayRefundStatus.RUNNING;
+                }
+                for (MultiOrderRefundResponse.RefundPlatformResponse refundPlatformResponse : refundPlatformResponseList) {
+                    if (refundPlatformResponse.getResultCode().compareTo(MultiOrderRefundResponse.RefundPlatformResponse.REFUND_SUCCESS) != 0) {
+                        message = refundPlatformResponse.getResultMsg() + ";" + message;
+                    }
+                }
+            }
+        }
+
+        PayRefundResponse payRefundResponse = handlePayRefundResponse(refundStatus, req.getRefundTradeNo());
+        if (StringUtils.isNotEmpty(message)) {
+            payRefundResponse.setMessage(message);
+        }
+        return payRefundResponse;
+    }
+
+
+    /**
+     * 代付退款
+     */
+    public PayRefundResponse agentPayRefund(String partnerId, String storeCode, String orderCode, BigDecimal refundAmount, String fmTradeNo) {
+        PayRefundStatus refundStatus = PayRefundStatus.SUCCESS;
+        String fmRefundNo = "";
+        try {
+            AgentPayRefundReq req = paymentSdkAdapter.getAgentPayRefundReq(partnerId, storeCode, orderCode, refundAmount, fmTradeNo);
+            AgentPayRefundResp resp = mulitiPaymentClient.agentPayRefund(req);
+            if (!resp.isOk()) {
+                refundStatus = PayRefundStatus.FAIL;
+            }
+            AgentPayRefundResp.DataDTO data = resp.getData();
+            if (Objects.nonNull(data)) {
+                refundStatus = this.getFinalRefundStatus(data.getResultCode());
+                fmRefundNo = data.getFmRefundNo();
+            }
+        } catch (Throwable e) {
+            refundStatus = PayRefundStatus.FAIL;
+        }
+        return this.handlePayRefundResponse(refundStatus, fmRefundNo);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    private PayRefundStatus getFinalRefundStatus(Integer resultCode) {
+        return PayRefundStatus.getByPayResultCode(resultCode);
+    }
+
+    private PayRefundResponse handlePayRefundResponse(PayRefundStatus refundStatus, String refundId) {
+        PayRefundResponse payRefundResponse = new PayRefundResponse();
+        payRefundResponse.setPayRefundStatus(refundStatus);
+        payRefundResponse.setRefundId(refundId);
+        payRefundResponse.setMessage(refundStatus.getDesc());
+        return payRefundResponse;
+    }
+
+}

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

@@ -2,36 +2,31 @@ package cn.freemud.management.service.handle;
 
 import cn.freemud.management.adapter.PaymentSdkAdapter;
 import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
-import cn.freemud.management.entities.dto.request.pay.AgentPayRefundReq;
 import cn.freemud.management.entities.dto.request.pay.PayRefundRequestDto;
 import cn.freemud.management.entities.dto.request.pay.PaymentQueryOrderRequestDto;
-import cn.freemud.management.entities.dto.response.pay.*;
+import cn.freemud.management.entities.dto.response.pay.OrderRefundResponse;
+import cn.freemud.management.entities.dto.response.pay.PayRefundData;
+import cn.freemud.management.entities.dto.response.pay.PayRefundResponse;
+import cn.freemud.management.entities.dto.response.pay.PaymentQueryOrderResponseDto;
 import cn.freemud.management.enums.PaymentRefundStatus;
 import cn.freemud.management.enums.ResponseResult;
 import cn.freemud.management.intercept.OrderServiceException;
-import cn.freemud.management.thirdparty.MulitiPaymentClient;
 import cn.freemud.management.thirdparty.OMSPaymentClient;
-import cn.freemud.management.util.RedisUtil;
-import cn.freemud.redis.RedisCache;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 import com.freemud.application.sdk.api.base.BaseResponse;
 import com.freemud.application.sdk.api.log.ErrorLog;
 import com.freemud.application.sdk.api.ordercenter.entities.v1.OrderBeanV1;
 import com.freemud.application.sdk.api.ordercenter.enums.OrderClientType;
-import com.freemud.application.sdk.api.ordercenter.enums.PayChannelType;
 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.OrderBaseResp;
 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.service.OrderSdkService;
 import com.freemud.application.sdk.api.ordercenter.util.LogUtil;
 import com.freemud.application.sdk.api.util.ResponseUtils;
 import com.freemud.sdk.api.assortment.order.enums.PayRefundStatus;
-import com.freemud.sdk.api.assortment.order.request.order.MultiOrderRefundRequest;
-import com.freemud.sdk.api.assortment.order.response.order.MultiOrderRefundResponse;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang.ObjectUtils;
 import org.apache.commons.lang.StringUtils;
@@ -39,8 +34,10 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.math.BigDecimal;
-import java.util.*;
-import java.util.concurrent.TimeUnit;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 
 
 /**
@@ -70,9 +67,7 @@ public class PaymentHandle {
     @Autowired
     private OrderSdkService orderSdkService;
     @Autowired
-    private MulitiPaymentClient mulitiPaymentClient;
-    @Autowired
-    private RedisCache redisCache;
+    private MultiRefundService multiRefundService;
     @Autowired
     private OMSPaymentClient paymentNewClient;
     @Autowired
@@ -88,15 +83,15 @@ public class PaymentHandle {
         try {
             BigDecimal refundAmount = getRefundAmount(orderBean.getCompanyId(), new BigDecimal(orderBean.getAmount()), orderBean.getOid());
             //订单支付明细表新saas都会存数据，ka,pass商户需要兼容
-            if (getMultiRefund(orderBean.getOrderPayItem())) {
-                //  payment/application/refund
-                refundResponse = this.multiRefund(orderBean.getCompanyId(), orderBean.getShopId(), orderBean.getOid(), refundAmount);
+            PayRefundResponse multiRefundResponse = multiRefundService.multiRefund(orderBean.getCompanyId(), orderBean.getShopId(), orderBean.getOid(), refundAmount, orderBean.getOrderPayItem());
+            if (multiRefundResponse != null) {
+                refundResponse = multiRefundResponse;
             }else {
                 OrderExtendedReq extended = orderBean.getOrderExtended();
                 if (StringUtils.isNotBlank(extended.getAgentPayerId()) && !Objects.equals(extended.getAgentPayerId(), orderBean.getUserId())) {
                     OrderExtInfoDto ext = JSON.parseObject(orderBean.getExtInfo(), OrderExtInfoDto.class);
                     //代付人信息不为空  并且和订单创建人不一样，表示代付单   payment/application/agentRefund
-                    refundResponse = this.agentPayRefund(orderBean.getCompanyId(), orderBean.getShopId(), orderBean.getOid(), refundAmount, ext.getPayTransId());
+                    refundResponse = multiRefundService.agentPayRefund(orderBean.getCompanyId(), orderBean.getShopId(), orderBean.getOid(), refundAmount, ext.getPayTransId());
                 } else {
                     //正常订单现金退款  paymentcenter/refund
                     PayRefundRequestDto req = paymentSdkAdapter.getOrderRefundRequest(orderBean.getCompanyId(), orderBean.getShopId(),
@@ -131,26 +126,6 @@ public class PaymentHandle {
     }
 
     /**
-     * 是否混合支付退款 有储值卡支付，调混合支付退款接口
-     * @param orderPayItems
-     * @return
-     */
-    private Boolean getMultiRefund(List<OrderPayItemResp> orderPayItems){
-        boolean isMultiRefund = false;
-        if(CollectionUtils.isEmpty(orderPayItems)){
-            return isMultiRefund;
-        }
-        List<Integer> multiPayChannelType = Arrays.asList(3,10,50,51,52);
-        for(OrderPayItemResp orderPayItemResp : orderPayItems){
-            //有储值卡支付，调混合支付退款
-            if(multiPayChannelType.contains(orderPayItemResp.getPayChannelType())){
-                isMultiRefund = true;
-            }
-        }
-        return isMultiRefund;
-    }
-
-    /**
      * 点餐订单退款入口
      * 支付退款，包含纯现金，代付，混合支付
      *
@@ -162,15 +137,17 @@ public class PaymentHandle {
         PayRefundResponse refundResponse;
         try {
             BigDecimal refundAmount = getRefundAmount(order.getPartnerId(), order.getSettlementAmount(), order.getOrderCode());
-            if (CollectionUtils.isNotEmpty(order.getOrderPayItemCreateReqList())) {
+
+            PayRefundResponse multiRefundResponse = multiRefundService.multiRefund(order.getPartnerId(), order.getStoreId(), order.getOrderCode(), refundAmount, order.getOrderPayItemCreateReqList());
+            if (multiRefundResponse != null) {
                 //  payment/application/refund
-                refundResponse = this.multiRefund(order.getPartnerId(), order.getStoreId(), order.getOrderCode(), refundAmount);
+                refundResponse = multiRefundResponse;
             } else {
                 OrderExtendedReq extended = order.getOrderExtended();
                 if (StringUtils.isNotBlank(extended.getAgentPayerId()) && !Objects.equals(extended.getAgentPayerId(), order.getUserId())) {
                     OrderExtInfoDto ext = JSON.parseObject(order.getExtInfo(), OrderExtInfoDto.class);
                     //代付人信息不为空  并且和订单创建人不一样，表示代付单   payment/application/agentRefund
-                    refundResponse = this.agentPayRefund(order.getPartnerId(), order.getStoreId(), order.getOrderCode(), refundAmount, ext.getPayTransId());
+                    refundResponse = multiRefundService.agentPayRefund(order.getPartnerId(), order.getStoreId(), order.getOrderCode(), refundAmount, ext.getPayTransId());
                 } else {
                     //正常订单现金退款  paymentcenter/refund
                     PayRefundRequestDto req = paymentSdkAdapter.getOrderRefundRequest(order.getPartnerId(), order.getStoreId(),
@@ -232,75 +209,10 @@ public class PaymentHandle {
     }
 
     /**
-     * 混合支付退款
-     */
-    private PayRefundResponse multiRefund(String partnerId, String storeCode, String orderCode, BigDecimal refundAmount) {
-        PayRefundStatus refundStatus = PayRefundStatus.SUCCESS;
-        MultiOrderRefundRequest req = paymentSdkAdapter.getMultiOrderPayRefundRequest(partnerId, storeCode, orderCode, refundAmount);
-        MultiOrderRefundResponse resp = mulitiPaymentClient.paymentApplicationRefund(req, partnerId);
-        String message = "";
-        if (Objects.isNull(resp) || resp.getCode() != 200) {
-            refundStatus = PayRefundStatus.FAIL;
-        } else {
-            MultiOrderRefundResponse.RefundPlatform data = resp.getData();
-            if (Objects.isNull(data) || CollectionUtils.isEmpty(data.refundPlatformResponseList)) {
-                refundStatus = PayRefundStatus.FAIL;
-            } else {
-                List<MultiOrderRefundResponse.RefundPlatformResponse> refundPlatformResponseList = data.refundPlatformResponseList;
-                redisCache.save(RedisUtil.getPaymentTransIdSequenceKey(refundPlatformResponseList.get(0).getTransId()), orderCode, 1L, TimeUnit.DAYS);
-
-                long refundError = refundPlatformResponseList.stream()
-                        .filter(s -> s.getResultCode().compareTo(MultiOrderRefundResponse.RefundPlatformResponse.REFUNDED_RESULTCODE) != 0
-                                && s.getResultCode().compareTo(MultiOrderRefundResponse.RefundPlatformResponse.REFUND_SUCCESS) != 0)
-                        .count();
-                if (refundError > 0L) {
-                    refundStatus = PayRefundStatus.FAIL;
-                }
-                // 退款中
-                long refunded = refundPlatformResponseList.stream()
-                        .filter(s -> s.getResultCode().compareTo(MultiOrderRefundResponse.RefundPlatformResponse.REFUNDED_RESULTCODE) == 0)
-                        .count();
-                if (refunded > 0L) {
-                    refundStatus = PayRefundStatus.RUNNING;
-                }
-                for (MultiOrderRefundResponse.RefundPlatformResponse refundPlatformResponse : refundPlatformResponseList) {
-                    if (refundPlatformResponse.getResultCode().compareTo(MultiOrderRefundResponse.RefundPlatformResponse.REFUND_SUCCESS) != 0) {
-                        message = refundPlatformResponse.getResultMsg() + ";" + message;
-                    }
-                }
-            }
-        }
-
-        PayRefundResponse payRefundResponse = handlePayRefundResponse(refundStatus, req.getRefundTradeNo());
-        if (StringUtils.isNotEmpty(message)) {
-            payRefundResponse.setMessage(message);
-        }
-        return payRefundResponse;
-    }
-
-    /**
      * 代付订单退款
      *
      */
-    private PayRefundResponse agentPayRefund(String partnerId, String storeCode, String orderCode, BigDecimal refundAmount, String fmTradeNo) {
-        PayRefundStatus refundStatus = PayRefundStatus.SUCCESS;
-        String fmRefundNo = "";
-        try {
-            AgentPayRefundReq req = paymentSdkAdapter.getAgentPayRefundReq(partnerId, storeCode, orderCode, refundAmount, fmTradeNo);
-            AgentPayRefundResp resp = mulitiPaymentClient.agentPayRefund(req);
-            if (!resp.isOk()) {
-                refundStatus = PayRefundStatus.FAIL;
-            }
-            AgentPayRefundResp.DataDTO data = resp.getData();
-            if (Objects.nonNull(data)) {
-                refundStatus = this.getFinalRefundStatus(data.getResultCode());
-                fmRefundNo = data.getFmRefundNo();
-            }
-        } catch (Throwable e) {
-            refundStatus = PayRefundStatus.FAIL;
-        }
-        return this.handlePayRefundResponse(refundStatus, fmRefundNo);
-    }
+
 
 
     private PayRefundStatus getFinalRefundStatus(Integer resultCode) {

order-management/src/main/java/cn/freemud/management/service/impl/MallOrderMangerServiceImpl.java

@@ -182,11 +182,7 @@ public class MallOrderMangerServiceImpl implements OrderManagerService {
 
 
     /**
-     * 提取 退款公共代码
-     *
-     * @param request
-     * @param orderBean
-     * @return
+     * 老的微商城退款 废弃
      */
     private PayRefundResponse payRefundCommon(OrderManagerRequest request, OrderBeanV1 orderBean) {
         PayRefundResponse refundResponse = paymentHandle.getCommonPayRefundResponse(request, orderBean);

order-management/src/main/java/cn/freemud/management/service/impl/NewMallOrderMangerServiceImpl.java

@@ -84,27 +84,6 @@ public class NewMallOrderMangerServiceImpl implements OrderManagerService {
             if (refundResponse.getPayRefundStatus().getCode().compareTo(PayRefundStatus.SUCCESS.getCode()) != 0) {
                 return ResponseUtil.error(ResponseResult.REFUND_FAIL_WAIT_CALLBACK);
             }
-//            PayRefundResponse refundResponse;
-//            boolean cashPay = false;
-//            boolean svcPay = false;
-//            if(CollectionUtils.isNotEmpty(orderBean.getOrderPayItem())){
-//                for (OrderPayItemResp  payItemResp : orderBean.getOrderPayItem()){
-//                    if(Objects.equals(payItemResp.getPayChannelType(),(int)PayChannelType.SVC.getIndex())){
-//                        svcPay = true;
-//                    }
-//                    if(Objects.equals(payItemResp.getPayChannelType(),(int)PayChannelType.WECHAT.getIndex())){
-//                        cashPay = true;
-//                    }
-//                    if(Objects.equals(payItemResp.getPayChannelType(),(int)PayChannelType.ALIPAY.getIndex())){
-//                        cashPay = true;
-//                    }
-//                }
-//            }
-//            if (cashPay && svcPay) {
-//                refundResponse = paymentHandle.multiRefund(orderBean);
-//            } else {
-//                refundResponse = paymentHandle.getCommonPayRefundResponse(request, orderBean);
-//            }
             //订单同意退款
             mallOrderHandle.refundAgree(request, refundResponse, orderBean);
             //冲正库存
@@ -141,11 +120,7 @@ public class NewMallOrderMangerServiceImpl implements OrderManagerService {
 
 
     /**
-     * 提取 退款公共代码
-     *
-     * @param request
-     * @param orderBean
-     * @return
+     * 新版商城退款
      */
     private PayRefundResponse payRefundCommon(OrderManagerRequest request, OrderBeanV1 orderBean) {
         PayRefundResponse refundResponse = paymentHandle.getCommonPayRefundResponse(request, orderBean);

order-management/src/main/java/cn/freemud/management/service/impl/SaasOrderMangerServiceImpl.java

@@ -209,9 +209,7 @@ public class SaasOrderMangerServiceImpl implements OrderManagerService {
     @Override
     public BaseResponse<OrderManagerResponse> orderReject(OrderManagerRequest request, OrderBeanV1 orderBean) {
         PayRefundResponse refundResponse = null;
-        // 只有线上付款的订单，拒单的时候才走退款流程
-        if (PayType.ONLINE_PAY.getCode().equals(orderBean.getPayType())) {
-            //支付退款
+        // 支付退款 包括线上小程序付款的订单，订单宝其他支付方式收款（汇来米，收钱吧，现金，其他）
         refundResponse = this.payRefundCommon(request, orderBean);
         // 退款异常
         if (refundResponse.getPayRefundStatus().getCode().compareTo(PayRefundStatus.COMPATIBILITY_STATUS.getCode()) == 0) {
@@ -221,13 +219,6 @@ public class SaasOrderMangerServiceImpl implements OrderManagerService {
         if (refundResponse.getPayRefundStatus().getCode().compareTo(PayRefundStatus.FAIL.getCode()) == 0) {
             return ResponseUtil.error(ResponseResult.REFUND_FAIL.getCode(), refundResponse.getMessage());
         }
-        } else {
-            // 线下退款，直接默认为退款成功
-            refundResponse = new PayRefundResponse();
-            refundResponse.setRefundId(UUID.randomUUID().toString().replaceAll("-", ""));
-            refundResponse.setPayRefundStatus(PayRefundStatus.SUCCESS);
-            refundResponse.setMessage(PayRefundStatus.SUCCESS.getDesc());
-        }
 
         //订单拒单
         saasOrderHandle.orderReject(request, refundResponse, orderBean);
@@ -280,11 +271,7 @@ public class SaasOrderMangerServiceImpl implements OrderManagerService {
     }
 
     /**
-     * 提取 退款公共代码
-     *
-     * @param request
-     * @param orderBean
-     * @return
+     * 拒单退款、同意退款、取消订单退款
      */
     private PayRefundResponse payRefundCommon(OrderManagerRequest request, OrderBeanV1 orderBean) {
         PayRefundResponse refundResponse = paymentHandle.getCommonPayRefundResponse(request, orderBean);